@nutrien-br/liborgs 1.0.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@nutrien-br/liborgs",
+  "version": "1.0.0",
+  "description": "lib to database orgs",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.js",
+  "typings": "lib/my-lib.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "test": "NODE_ENV=test vitest --coverage --silent",
+    "test:dev": "NODE_ENV=test vitest --coverage"
+  },
+  "keywords": [
+    "orgs",
+    "sequelize",
+    "models"
+  ],
+  "author": "Johnny Moreira",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.19.37",
+    "@types/pg": "^8.18.0",
+    "@types/sequelize": "^4.28.20",
+    "@vitest/coverage-v8": "^4.0.18",
+    "sqlite3": "^5.1.7",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "umzug": "^3.8.2",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "dotenv": "^17.3.1",
+    "pg": "^8.20.0",
+    "pg-hstore": "^2.3.4",
+    "sequelize": "^6.37.8",
+    "zod": "^4.3.6"
+  }
+}

package/src/core/entity/CreditSourceSchema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const CreditSourceSchema = z.object({
+  csrcId: z.number().positive(),
+  csrcName: z.string().min(1, "O nome é obrigatório"),
+  csrcType: z.enum(['PARTNER', 'IN_HOUSE'], {
+    error: "O tipo deve ser PARTNER ou IN_HOUSE",
+  }),
+});
+
+
+export const CreateCreditSourceSchema = CreditSourceSchema.omit({ csrcId: true });
+
+export type CreditSourceEntity = z.infer<typeof CreditSourceSchema>;
+export type CreateCreditSourceEntity = z.infer<typeof CreateCreditSourceSchema>;

package/src/core/entity/schFinancial/CreditAnalysisResultSchema.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+export const CreditAnalysisResultSchema = z.object({
+  careId: z.number().int().optional(),
+  careExternalId: z.string().max(255),
+  careRequestedLimit: z.number().nonnegative().optional(),
+  careApprovedLimit: z.number().nonnegative().optional(),
+  careDateSolicitation: z.date().optional(),
+  careResponseDate: z.date().optional().nullable(),
+  careResponse: z.boolean().default(false),
+  careRequestId: z.string().uuid(),
+  soliId: z.number().int(),
+  csrcId: z.number().int(),
+});
+
+export type CreditAnalysisResultEntity = z.infer<typeof CreditAnalysisResultSchema>;
+export type CreateCreditAnalysisResultEntity = z.input<typeof CreditAnalysisResultSchema>;

package/src/core/entity/schFinancial/CreditSourceLimitHistorySchema.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+export const CreditSourceLimitHistorySchema = z.object({
+  cslhId: z.number().int().optional(),
+  csrcId: z.number().int(),
+  persId: z.number().int().nullable().optional(),
+  compId: z.number().int().nullable().optional(),
+  cslhTotalLimit: z.number().nonnegative(),
+  cslhUsedLimit: z.number().nonnegative(),
+  cslhAvailableLimit: z.number().optional(),
+  cslhReferenceDate: z.coerce.date(),
+  cslhCreatedAt: z.date().optional(),
+}).refine(
+  (data) => {
+    const hasPerson = !!data.persId;
+    const hasCompany = !!data.compId;
+    return (hasPerson && !hasCompany) || (!hasPerson && hasCompany);
+  },
+  {
+    message: "O histórico deve pertencer exclusivamente a uma Pessoa ou a uma Empresa.",
+    path: ["persId"],
+  }
+).refine(
+  (data) => data.cslhUsedLimit <= data.cslhTotalLimit,
+  {
+    message: "O limite usado não pode ser maior que o limite total.",
+    path: ["cslhUsedLimit"],
+  }
+);
+
+export type CreditSourceLimitHistoryEntity = z.infer<typeof CreditSourceLimitHistorySchema>;
+export type CreateCreditSourceLimitHistoryEntity = z.input<typeof CreditSourceLimitHistorySchema>;

package/src/core/entity/schFinancial/RateRulesSchema.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const RateRulesSchema = z.object({
+  raruId: z.number().int().optional(),
+  raruVersion: z.number().int().optional(),
+  raruRating: z.string().max(2),
+  raruInHousePercentage: z.number().min(0).max(100),
+  raruPartnerPercentage: z.number().min(0).max(100),
+}).refine(
+  (data) => {
+    const sum = Number(data.raruInHousePercentage) + Number(data.raruPartnerPercentage);
+    return Math.abs(sum - 100) < 0.01;
+  },
+  {
+    message: "A soma das porcentagens (In House + Partner) deve ser exatamente 100%.",
+    path: ["raruInHousePercentage"],
+  }
+);
+
+export type RateRulesEntity = z.infer<typeof RateRulesSchema>;
+export type CreateRateRulesEntity = z.input<typeof RateRulesSchema>;

package/src/core/entity/schFinancial/SolicitationNfSchema.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const SolicitationNfSchema = z.object({
+  sonfId: z.number().int().optional(),
+  sonfSumNf: z.number().nonnegative().optional(),
+  sonfCompleted: z.boolean().default(false),
+  sonfRequestId: z.string().uuid(),
+  soliId: z.number().int(),
+});
+
+export type SolicitationNfEntity = z.infer<typeof SolicitationNfSchema>;
+export type CreateSolicitationNfEntity = z.input<typeof SolicitationNfSchema>;

package/src/core/entity/schFinancial/SolicitationRateSchema.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+export const SolicitationRateSchema = z.object({
+  soraId: z.number().int().optional(),
+  soraRating: z.string().max(2).optional(),
+  soraInHousePercentage: z.number().min(0).max(100),
+  soraPartnerPercentage: z.number().min(0).max(100),
+  soraInHouseAllocation: z.number().nonnegative(),
+  soraPartnerAllocation: z.number().nonnegative(),
+  soliId: z.number().int(),
+}).refine(
+  (data) => {
+    const sum = Number(data.soraInHousePercentage) + Number(data.soraPartnerPercentage);
+    return Math.abs(sum - 100) < 0.01;
+  },
+  {
+    message: "A soma das porcentagens (In House + Partner) deve ser exatamente 100%.",
+    path: ["soraInHousePercentage"],
+  }
+);
+
+export type SolicitationRateEntity = z.infer<typeof SolicitationRateSchema>;
+export type CreateSolicitationRateEntity = z.input<typeof SolicitationRateSchema>;

package/src/core/entity/schFinancial/SolicitationRevenueSchema.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const SolicitationRevenueSchema = z.object({
+  soreId: z.number().int().optional(),
+  soreRevenue: z.number().nonnegative().optional(),
+  soreCompleted: z.boolean().default(false),
+  soreRequestId: z.string().uuid(),
+  soliId: z.number().int(),
+});
+
+export type SolicitationRevenueEntity = z.infer<typeof SolicitationRevenueSchema>;
+export type CreateSolicitationRevenueEntity = z.input<typeof SolicitationRevenueSchema>;

package/src/core/entity/schFinancial/SolicitationSchema.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+export const SolicitationSchema = z.object({
+  soliId: z.number().optional(),
+  soliRequestedLimit: z.number().positive(),
+  soliCompleted: z.boolean().default(false),
+
+  persId: z.number().int().nullable().optional(),
+  compId: z.number().int().nullable().optional(),
+}).refine(
+  (data) => {
+    const hasPerson = data.persId !== null && data.persId !== undefined;
+    const hasCompany = data.compId !== null && data.compId !== undefined;
+    return (hasPerson && !hasCompany) || (!hasPerson && hasCompany);
+  },
+  {
+    message: "A solicitação deve pertencer obrigatoriamente a uma Pessoa ou a uma Empresa (exclusivamente).",
+    path: ["persId"],
+  }
+);
+
+export type SolicitationEntity = z.infer<typeof SolicitationSchema>;
+export type CreateSolicitationEntity = z.input<typeof SolicitationSchema>;

package/src/core/entity/schOrgs/CompanySchema.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const CompanySchema = z.object({
+  compId: z.number().optional(),
+  compDes: z.string().max(60).nullable().optional(),
+  compCorporateName: z.string().max(300),
+  compRegistration: z.string().max(20).nullable().optional(),
+  compUuid: z.string().uuid().optional(),
+  compObs: z.string().max(4000).nullable().optional(),
+  compRegisDate: z.date(),
+  compRegisUser: z.string().max(100),
+  compErpRegisDate: z.date().optional(),
+});
+
+export type CompanyEntity = z.infer<typeof CompanySchema>;
+export type CreateCompanyEntity = z.input<typeof CompanySchema>;

package/src/core/entity/schOrgs/PersonSchema.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+export const PersonSchema = z.object({
+  persId: z.number().optional(),
+  persName: z.string().max(100),
+  persSocialName: z.string().max(100).nullable().optional(),
+  persFirstName: z.string().max(50).nullable().optional(),
+  persLastName: z.string().max(50).nullable().optional(),
+  persBirthDate: z.date().nullable().optional(),
+  persMothersName: z.string().max(100).nullable().optional(),
+  persFathersName: z.string().max(100).nullable().optional(),
+  persIndSex: z.string().length(1),
+  persRegistration: z.string().max(20).nullable().optional(),
+  persUuid: z.string().uuid().optional(),
+  mastCod: z.string().max(10).nullable().optional(),
+  gendCod: z.string().max(10).nullable().optional(),
+  persObs: z.string().max(4000).nullable().optional(),
+  persRegisDate: z.date(),
+  persRegisUser: z.string().max(50),
+  persErpRegisDate: z.date().optional(),
+});
+
+export type PersonEntity = z.infer<typeof PersonSchema>;
+export type CreatePersonEntity = z.input<typeof PersonSchema>;

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './infra/models/initModels'
+export * from './utils/initMock'

package/src/infra/config/params.ts

@@ -0,0 +1,17 @@
+import dotenv from "dotenv";
+import { z } from "zod";
+dotenv.config();
+
+const envSchema = z.object({
+  PORT: z.string().default("80"),
+  NODE_ENV: z.enum(["dev", "test", "sit", "preProd", "production"]).default("dev"),
+  DATABASE_USERNAME: z.string().optional(),
+  DATABASE_PASSWORD: z.string().optional(),
+  DATABASE_NAME: z.string().optional(),
+  DATABASE_HOST: z.string().optional(),
+  DATABASE_PORT: z.string().optional(),
+  DATABASE_PORT_WRITE: z.string().optional(),
+  DATABASE_PORT_READ: z.string().optional()
+});
+
+export const ENV = envSchema.parse(process.env);

package/src/infra/database/Database.ts

@@ -0,0 +1,33 @@
+import { Sequelize } from 'sequelize';
+import { IDatabaseStrategy } from './strategies/IDatabaseStrategy';
+import { PostgresStrategy } from './strategies/PostgresStrategy';
+import { SqliteStrategy } from './strategies/SqliteStrategy';
+
+export default class Database {
+  private static instance: Sequelize;
+
+  static getConnection(): Sequelize {
+    if (!Database.instance) {
+      const strategy = Database.resolveStrategy();
+      Database.instance = strategy.connect();
+    }
+    return Database.instance;
+  }
+
+  private static resolveStrategy(): IDatabaseStrategy {
+    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);
+  }
+}

package/src/infra/database/migrate.ts

@@ -0,0 +1,52 @@
+import { Umzug, SequelizeStorage } from "umzug";
+import Database from "./Database";
+import { config } from 'dotenv'
+
+// const getEnv = (stage?: string) => {
+//   switch (stage) {
+//     case 'stg':
+//       return '.env.stg'
+//     case 'prod':
+//       return '.env.prod'
+//     default:
+//       return '.env'
+//   }
+// }
+
+const path = process.env.NODE_ENV //getEnv(process.env.NODE_ENV)
+console.log('> READING DOT ENV', path)
+config({ path })
+console.log('> NODE_ENV', process.env.NODE_ENV)
+console.log('> Connecting to', process.env.DATABASE_NAME, process.env.DATABASE_HOST);
+const sequelize = Database.getConnection()
+
+const umzug = new Umzug({
+  migrations: {
+    glob: "src/database/migrations/*.migration.ts"
+  },
+  context: sequelize,
+  storage: new SequelizeStorage({
+    sequelize,
+    modelName: "sequelize_meta"
+  }),
+  logger: console
+});
+
+const task = process.env.MIGRATION;
+console.log('> Running migration', task?.toUpperCase());
+switch (task) {
+  case "up":
+    umzug.up().then((result) => {
+      console.log("Migrations up went successful!", result);
+      process.exit(0);
+    });
+    break;
+  case "down":
+    umzug.down().then((result) => {
+      console.log("Migrations down went successful!", result);
+      process.exit(0);
+    });
+    break;
+  default:
+    break;
+}

package/src/infra/database/migrations/01_create_table_credit_source.migration.ts

@@ -0,0 +1,49 @@
+import { DataTypes } from 'sequelize';
+import { UmzugMigration } from '../umzug-migration.type';
+
+const table = {
+  name: 'credit_start',
+  schema: 'sch_financial'
+};
+
+export const up = async (migration: UmzugMigration) => {
+  const query = migration.context.getQueryInterface();
+
+  // await query.createSchema(table.schema).catch(() => {
+  // });
+
+  await query.createTable(
+    {
+      tableName: table.name,
+      schema: table.schema
+    },
+    {
+      csrc_id: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      csrc_name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      csrc_type: {
+        type: DataTypes.ENUM('PARTNER', 'IN_HOUSE'),
+        allowNull: false,
+      }
+    }
+  );
+};
+
+export const down = async (migration: UmzugMigration) => {
+  const query = migration.context.getQueryInterface();
+
+  await query.dropTable({
+    tableName: table.name,
+    schema: table.schema
+  });
+
+  // TODO: se precisar remover o enum descomentar essa linha, ele é global no postgres
+  // await query.sequelize.query(`DROP TYPE IF EXISTS "${table.schema}"."enum_credit_start_csrc_type";`);
+};

package/src/infra/database/seed.ts

@@ -0,0 +1,35 @@
+import { Umzug, SequelizeStorage } from "umzug";
+import Database from "./Database";
+
+const sequelize = Database.getConnection()
+
+const umzug = new Umzug({
+  migrations: {
+    glob: "src/database/seeds/*.seed.ts"
+  },
+  context: sequelize,
+  storage: new SequelizeStorage({
+    sequelize,
+    modelName: "seeder_meta"
+  }),
+  logger: console
+});
+
+const task = process.env.MIGRATION;
+
+switch (task) {
+  case "up":
+    umzug.up().then((result) => {
+      console.log("Seeds up went successful!", result);
+      process.exit(0);
+    });
+    break;
+  case "down":
+    umzug.down().then((result) => {
+      console.log("Seeds down went successful!", result);
+      process.exit(0);
+    });
+    break;
+  default:
+    break;
+}

package/src/infra/database/seeds/01_create_seed_credit_source.seed.ts

@@ -0,0 +1,55 @@
+import type { UmzugSeed } from "../umzug-migration.type";
+
+const table = {
+  name: 'credit_start',
+  schema: 'sch_financial',
+};
+
+const seed = [
+  {
+    csrc_id: 1,
+    csrc_name: 'FARM',
+    csrc_type: 'PARTNER'
+  },
+  {
+    csrc_id: 2,
+    csrc_name: 'SUPPLIER',
+    csrc_type: 'PARTNER'
+  },
+  {
+    csrc_id: 3,
+    csrc_name: 'SELLOR',
+    csrc_type: 'PARTNER'
+  },
+  {
+    csrc_id: 4,
+    csrc_name: 'NUTRIEN',
+    csrc_type: 'IN_HOUSE'
+  },
+];
+
+export const up = async (migration: UmzugSeed) => {
+  const query = migration.context.getQueryInterface();
+
+  await query.bulkInsert(
+    {
+      tableName: table.name,
+      schema: table.schema
+    },
+    seed,
+  );
+};
+
+export const down = async (migration: UmzugSeed) => {
+  const query = migration.context.getQueryInterface();
+
+  await query.bulkDelete(
+    {
+      tableName: table.name,
+      schema: table.schema
+    },
+    {
+      csrc_id: seed.map((s) => s.csrc_id)
+    },
+  );
+};

package/src/infra/database/strategies/IDatabaseStrategy.ts

@@ -0,0 +1,5 @@
+import { Sequelize } from 'sequelize';
+
+export interface IDatabaseStrategy {
+  connect(): Sequelize;
+}

package/src/infra/database/strategies/PostgresStrategy.ts

@@ -0,0 +1,17 @@
+import { Sequelize } from 'sequelize';
+import pg from 'pg';
+import { IDatabaseStrategy } from './IDatabaseStrategy';
+
+export class PostgresStrategy implements IDatabaseStrategy {
+  constructor(private config: any) { }
+
+  connect(): Sequelize {
+    return new Sequelize({
+      ...this.config,
+      dialect: 'postgres',
+      dialectModule: pg,
+      logging: false,
+      pool: { max: 20, min: 5, acquire: 30000, idle: 10000 },
+    });
+  }
+}

package/src/infra/database/strategies/SqliteStrategy.ts

@@ -0,0 +1,14 @@
+import { Sequelize } from 'sequelize';
+import { IDatabaseStrategy } from './IDatabaseStrategy';
+
+export class SqliteStrategy implements IDatabaseStrategy {
+  constructor(private storage?: string) { }
+
+  connect(): Sequelize {
+    return new Sequelize({
+      dialect: 'sqlite',
+      storage: this.storage || ':memory:',
+      logging: false,
+    });
+  }
+}

package/src/infra/database/umzug-migration.type.ts

@@ -0,0 +1,9 @@
+import { Sequelize } from 'sequelize';
+
+export type UmzugMigration = {
+  context: Sequelize;
+  path: string;
+  name: string;
+};
+
+export type UmzugSeed = UmzugMigration;

package/src/infra/database/umzug.ts

@@ -0,0 +1,30 @@
+import { Umzug, SequelizeStorage } from "umzug";
+import database from "./Database";
+
+export const migrator = new Umzug({
+  migrations: {
+    glob: ["migrations/*.ts", { cwd: __dirname }]
+  },
+  context: database.getSequelize(),
+  storage: new SequelizeStorage({
+    sequelize: database.getSequelize(),
+    modelName: "migration_meta"
+  }),
+  logger: console
+});
+
+export const seeder = new Umzug({
+  migrations: {
+    glob: ["seeds/*.ts", { cwd: __dirname }]
+  },
+  context: database.getSequelize(),
+  storage: new SequelizeStorage({
+    sequelize: database.getSequelize(),
+    modelName: "seeder_meta"
+  }),
+  logger: console
+});
+
+export type Migration = typeof migrator._types.migration;
+export type Seeder = typeof seeder._types.migration;
+

package/src/infra/models/initModels.ts

@@ -0,0 +1,58 @@
+import Database from "../database/Database";
+import { CreditAnalysisResult } from "./schFinancial/CreditAnalysisResult";
+import { CreditSource } from "./schFinancial/CreditSource";
+import { CreditSourceLimitHistory } from "./schFinancial/CreditSourceLimitHistory";
+import { RateRules } from "./schFinancial/RateRules";
+import { Solicitation } from "./schFinancial/Solicitation";
+import { SolicitationNf } from "./schFinancial/SolicitationNf";
+import { SolicitationRate } from "./schFinancial/SolicitationRate";
+import { SolicitationRevenue } from "./schFinancial/SolicitationRevenue";
+import { Company } from "./schOrgs/Company";
+import { Person } from "./schOrgs/Person";
+
+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;
+}
+
+// initModels()
+//   .then(() => logger.info(`Models initialized successfully [ENV: ${process.env.NODE_ENV}]`))
+//   .catch(err => logger.error(`Error initializing models: ${err.message}`, err));
+
+export {
+  initModels,
+  CreditSource,
+  Person,
+  Company,
+  Solicitation,
+  SolicitationRate,
+  RateRules,
+  SolicitationRevenue,
+  SolicitationNf,
+  CreditSourceLimitHistory,
+  CreditAnalysisResult
+};