@cheetah.js/orm 0.1.8 → 0.1.10

package/src/migration/diff-calculator.ts

@@ -0,0 +1,287 @@
+import { EntityStorage } from '../domain/entities';
+import { ColDiff, ColumnsInfo, SnapshotTable, TableDiff } from '@cheetah.js/orm/driver/driver.interface';
+
+export class DiffCalculator {
+  private entities: EntityStorage;
+
+  constructor(entities: EntityStorage) {
+    this.entities = entities;
+  }
+
+  diff(snapshotBd: SnapshotTable[], snapshotEntities: SnapshotTable[]): TableDiff[] {
+    let diffs: TableDiff[] = [];
+    // Cria um mapa (dicionário) para facilitar o acesso por nome da tabela
+    const bdTablesMap = new Map(snapshotBd.map(table => [table.tableName, table]));
+    const entityTablesMap = new Map(snapshotEntities.map(table => [table.tableName, table]));
+
+    // Junta todos os nomes de tabelas
+    const allTableNames = new Set([...bdTablesMap.keys(), ...entityTablesMap.keys()]);
+
+    allTableNames.forEach(tableName => {
+      const bdTable = bdTablesMap.get(tableName);
+      const entityTable = entityTablesMap.get(tableName);
+
+      if (!entityTable) {
+        // Se a tabela só está no banco de dados, precisamos deletá-la
+        diffs.push({
+          tableName,
+          colDiffs: [{actionType: 'DELETE', colName: '*'}], // Indica que todas as colunas devem ser deletadas (ou seja, a tabela inteira)
+        });
+      } else if (!bdTable) {
+        const colDiffs: ColDiff[] = entityTable.columns.flatMap(c => {
+          return this.createNewColumn(c, [])
+        });
+        this.checkIndexes(bdTable, entityTable, colDiffs)
+        // Se a tabela só está nas entidades, precisamos criá-la
+        diffs.push({
+          tableName,
+          newTable: true,
+          schema: entityTable.schema ?? 'public',
+          colDiffs,// Indica que todas as colunas devem ser criadas
+        });
+      } else {
+        const colDiffs: ColDiff[] = [];
+        // Se a tabela está em ambos, precisamos comparar as colunas
+        const bdColumnsMap = new Map(bdTable.columns.map(col => [col.name, col]));
+        const entityColumnsMap = new Map(entityTable.columns.map(col => [col.name, col]));
+        const allColumnNames = new Set([...bdColumnsMap.keys(), ...entityColumnsMap.keys()]);
+
+        this.checkIndexes(bdTable, entityTable, colDiffs)
+
+        allColumnNames.forEach(colName => {
+          const bdCol = bdColumnsMap.get(colName);
+          const entityCol = entityColumnsMap.get(colName);
+
+          if (!entityCol) {
+            colDiffs.push({
+              actionType: 'DELETE',
+              colName: bdCol!.name,
+            });
+          } else if (!bdCol) {
+            this.createNewColumn(entityCol, colDiffs);
+          } else this.diffColumnSql(bdCol, entityCol, colDiffs);
+        });
+
+        if (colDiffs.length > 0) {
+          diffs.push({
+            tableName: tableName,
+            schema: entityTable.schema ?? 'public',
+            colDiffs,
+          });
+        }
+      }
+    });
+
+    return diffs;
+  }
+
+  private checkIndexes(bdTable: SnapshotTable | undefined, entityTable: SnapshotTable | undefined, colDiffs: ColDiff[]) {
+    if ((bdTable && bdTable.indexes) || (entityTable && entityTable.indexes)) {
+      if (!bdTable || !bdTable.indexes) {
+        colDiffs.push({
+          actionType: 'INDEX',
+          colName: '*',
+          indexTables: entityTable!.indexes.map(index => ({
+            name: index.indexName,
+            properties: index.columnName.split(','),
+          })),
+        });
+      }
+
+      if (!entityTable || !entityTable.indexes) {
+        colDiffs.push({
+          actionType: 'INDEX',
+          colName: '*',
+          indexTables: bdTable!.indexes.map(index => ({name: index.indexName})),
+        });
+      }
+    }
+
+    if ((bdTable && bdTable.indexes) && (entityTable && entityTable.indexes)) {
+      const bdIndexesMap = new Map(bdTable.indexes.map(index => [index.indexName, index]));
+      const entityIndexesMap = new Map(entityTable.indexes.map(index => [index.indexName, index]));
+      const allIndexes = new Set([...bdIndexesMap.keys(), ...entityIndexesMap.keys()]);
+      allIndexes.forEach(indexName => {
+        const bdIndex = bdIndexesMap.get(indexName);
+        const entityIndex = entityIndexesMap.get(indexName);
+        if (!entityIndex) {
+          colDiffs.push({
+            actionType: 'INDEX',
+            colName: bdIndex!.columnName,
+            indexTables: [{name: indexName}],
+          });
+        } else if (!bdIndex) {
+          colDiffs.push({
+            actionType: 'INDEX',
+            colName: entityIndex.columnName,
+            indexTables: [{name: indexName, properties: entityIndex.columnName.split(',')}],
+          });
+        }
+      });
+    }
+  }
+
+  private createNewColumn(entityCol: ColumnsInfo, colDiffs: ColDiff[]): ColDiff[] {
+    const colType = this.convertEntityTypeToSqlType(entityCol.type);
+
+    colDiffs.push({
+      actionType: 'CREATE',
+      colName: entityCol.name,
+      colType: colType.type,
+      colLength: entityCol.length ?? colType.len,
+      colChanges: {
+        autoIncrement: entityCol.autoIncrement,
+        default: entityCol.default,
+        primary: entityCol.primary,
+        unique: entityCol.unique,
+        nullable: entityCol.nullable,
+        foreignKeys: entityCol.foreignKeys ?? [],
+      },
+    });
+
+    return colDiffs;
+  }
+
+  private diffColumnType(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]): void {
+    const colT = this.convertEntityTypeToSqlType(entityCol.type);
+    const colType = colT.type;
+    const length = entityCol.length ?? colT.len;
+    if (bdCol.type !== colType || bdCol.length !== length) {
+      colDiffs.push({
+        actionType: 'ALTER',
+        colName: entityCol.name,
+        colType: colType,
+        colLength: length,
+      });
+    }
+  }
+
+  private diffColumnDefault(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]): void {
+    if (bdCol.default !== entityCol.default) {
+      colDiffs.push({
+        actionType: 'ALTER',
+        colName: entityCol.name,
+        colChanges: {default: entityCol.default},
+        colLength: entityCol.length,
+      });
+    }
+  }
+
+  private diffColumnPrimary(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]): void {
+    if (bdCol.primary !== entityCol.primary) {
+      colDiffs.push({
+        actionType: 'ALTER',
+        colName: entityCol.name,
+        colChanges: {primary: entityCol.primary},
+        colLength: entityCol.length,
+      });
+    }
+  }
+
+  private diffColumnUnique(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]): void {
+    if (bdCol.unique !== entityCol.unique) {
+
+      if (bdCol.unique === false && entityCol.unique === undefined) {
+        return;
+      }
+
+      colDiffs.push({
+        actionType: 'ALTER',
+        colName: entityCol.name,
+        colChanges: {unique: entityCol.unique || false},
+        colLength: entityCol.length,
+      });
+    }
+  }
+
+  private diffForeignKey(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]): void {
+    if (bdCol.foreignKeys || entityCol.foreignKeys) {
+      const bdFKMap = new Map((bdCol.foreignKeys || []).map(fk => [`${fk.referencedTableName}.${fk.referencedColumnName}`, fk]));
+      const entityFKMap = new Map((entityCol.foreignKeys || []).map(fk => [`${fk.referencedTableName}.${fk.referencedColumnName}`, fk]));
+
+      const allFKs = new Set([...bdFKMap.keys(), ...entityFKMap.keys()]);
+
+      allFKs.forEach(fkName => {
+        const bdFK = bdFKMap.get(fkName);
+        const entityFK = entityFKMap.get(fkName);
+
+        if (!entityFK) {
+          colDiffs.push({
+            actionType: 'ALTER',
+            colName: bdCol.name,
+            colChanges: {
+              foreignKeys: bdCol.foreignKeys?.filter((fk: any) => fk !== bdFK),
+            },
+          });
+        }
+        // else if (!bdFK) {
+        //   console.log(bdFK, 'lu')
+        //   colDiffs.push({
+        //     actionType: 'ALTER',
+        //     colName: entityCol.name,
+        //     colChanges: {
+        //       foreignKeys: [...(bdCol.foreignKeys || []), entityFK],
+        //     },
+        //   });
+        // }
+      });
+
+    }
+  }
+
+  private diffColumnSql(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]) {
+    this.diffForeignKey(bdCol, entityCol, colDiffs);
+    this.diffColumnType(bdCol, entityCol, colDiffs);
+    this.diffColumnDefault(bdCol, entityCol, colDiffs);
+    this.diffColumnPrimary(bdCol, entityCol, colDiffs);
+    this.diffColumnUnique(bdCol, entityCol, colDiffs);
+    this.diffColumnNullable(bdCol, entityCol, colDiffs);
+
+    return colDiffs;
+  }
+
+  private diffColumnNullable(bdCol: ColumnsInfo, entityCol: ColumnsInfo, colDiffs: ColDiff[]) {
+    if (bdCol.nullable !== entityCol.nullable) {
+      colDiffs.push({
+        actionType: 'ALTER',
+        colName: entityCol.name,
+        colChanges: {nullable: entityCol.nullable},
+        colLength: entityCol.length,
+      });
+    }
+  }
+
+  // TODO: Precisa ser de acordo com o driver
+  // adicionar  'varchar' | 'text' | 'int' | 'bigint' | 'float' | 'double' | 'decimal' | 'date' | 'datetime' | 'time' | 'timestamp' | 'boolean' | 'json' | 'jsonb' | 'enum' | 'array' | 'uuid'
+  private convertEntityTypeToSqlType(entityType: string): { type: string, len?: number } {
+    switch (entityType) {
+      case "Number":
+      case 'int':
+        return {type: 'numeric', len: 11};
+      case 'bigint':
+        return {type: 'bigint'};
+      case 'float':
+        return {type: 'float4'};
+      case 'double':
+        return {type: 'float8'};
+      case 'decimal':
+        return {type: 'decimal'};
+      case "String":
+      case "varchar":
+        return {type: 'character varying', len: 255};
+      case "Boolean":
+        return {type: "boolean"};
+      case "Date":
+        return {type: "timestamp"};
+      case "Object":
+        return {type: "json"};
+      case 'uuid':
+        return {type: 'uuid'};
+      case 'text':
+        return {type: 'text'};
+      default:
+        return {type: "character varying", len: 255};
+      //... mais casos aqui ...
+    }
+  }
+}

package/src/migration/migrator.ts

@@ -0,0 +1,277 @@
+import 'reflect-metadata';
+import { ColDiff, ConnectionSettings, DriverInterface, SnapshotTable } from '../driver/driver.interface';
+import { globby } from 'globby'
+import { Orm, OrmService } from '@cheetah.js/orm';
+import { InjectorService, LoggerService } from '@cheetah.js/core';
+import { EntityStorage } from '../domain/entities';
+import * as path from 'path';
+import * as fs from 'fs';
+import { DiffCalculator } from './diff-calculator';
+
+export class Migrator {
+  config: ConnectionSettings<any>;
+  orm: Orm<any>;
+  entities: EntityStorage = new EntityStorage();
+
+  constructor() {
+  }
+
+  async initConfigFile(basePath: string = process.cwd()) {
+    const paths = await globby(['cheetah.config.ts'], {absolute: true, cwd: basePath})
+
+    if (paths.length === 0) {
+      throw new Error('Config file not found');
+    }
+
+    const config = await import(paths[0]);
+    this.config = config.default;
+
+    if (typeof this.config.entities === 'string') {
+      const paths = await globby(this.config.entities, {absolute: true, cwd: basePath})
+      for (const path of paths) {
+        await import(path);
+      }
+    }
+
+    this.orm = new Orm(new LoggerService(new InjectorService()));
+    this.entities = new EntityStorage();
+    const serv = new OrmService(this.orm, this.entities)
+    await serv.onInit(this.config);
+  }
+
+  async initMigration() {
+    const snapshotBd = await this.snapshotBd();
+    const snapshotEntities = await this.snapshotEntities();
+    const calculator = new DiffCalculator(this.entities);
+
+    return calculator.diff(snapshotBd, snapshotEntities);
+  }
+
+  private async snapshotBd(): Promise<SnapshotTable[]> {
+    const snapshot = []
+    for (let [_, values] of this.entities.entries()) {
+      const bd = await this.orm.driverInstance.snapshot(values.tableName);
+      if (!bd) {
+        continue;
+      }
+      snapshot.push(bd)
+    }
+    return snapshot;
+  }
+
+  private async snapshotEntities() {
+    const snapshot = []
+    for (let [_, values] of this.entities.entries()) {
+      snapshot.push(await this.entities.snapshot(values))
+    }
+    return snapshot;
+  }
+
+
+  async createMigration(forceName: string | null = null): Promise<void> {
+    const diff = await this.initMigration();
+    const migrationDirectory = path.join(process.cwd(), this.config.migrationPath ?? 'database/migrations');
+    const migrationFileName = (forceName ?? `migration_${new Date().toISOString().replace(/[^\d]/g, '')}`) + `.sql`;
+    const migrationFilePath = path.join(migrationDirectory, migrationFileName);
+
+    if (!fs.existsSync(migrationDirectory)) {
+      fs.mkdirSync(migrationDirectory, {recursive: true});
+    }
+
+    let sqlInstructions: string[] = [];
+
+    diff.forEach(tableDiff => {
+      const tableName = tableDiff.tableName;
+      const schema = tableDiff.schema;
+
+      if (tableDiff.newTable) {
+        const indexes = tableDiff.colDiffs.filter(colDiff => colDiff.actionType === 'INDEX');
+        const creates = tableDiff.colDiffs.filter(colDiff => colDiff.actionType === 'CREATE');
+        const fks = tableDiff.colDiffs.filter(colDiff => colDiff.colChanges?.foreignKeys);
+
+        sqlInstructions.push(this.orm.driverInstance.getCreateTableInstruction(schema, tableName, creates));
+
+        indexes.forEach(colDiff => {
+          colDiff.indexTables = colDiff.indexTables?.filter(index => index.name !== `${tableName}_pkey`);
+        });
+
+        fks.forEach(colDiff => {
+          colDiff.colChanges?.foreignKeys?.forEach(fk => {
+            sqlInstructions.push(this.orm.driverInstance.getAlterTableFkInstruction(schema, tableName, colDiff, fk));
+          });
+        });
+
+        sqlInstructions = sqlInstructions.map(sql => sql.replace(/' '/g, ''));
+        indexes.forEach(colDiff => {
+          if (colDiff.indexTables) {
+            colDiff.indexTables.forEach(index => {
+              if (index.properties) {
+                sqlInstructions.push(this.orm.driverInstance.getCreateIndex(index, schema, tableName));
+              }
+            });
+          }
+        })
+        return;
+      }
+
+      // Agrupar alterações por coluna
+      const colChangesMap = new Map<string, ColDiff[]>();
+
+      tableDiff.colDiffs.reverse().forEach(colDiff => {
+        const colName = colDiff.colName;
+
+        if (!colChangesMap.has(colName)) {
+          colChangesMap.set(colName, []);
+        }
+
+        colChangesMap.get(colName)?.push(colDiff);
+      });
+
+      // Gerar instruções SQL agrupadas por coluna
+      colChangesMap.forEach((colDiffs, colName) => {
+        const colDiffInstructions: string[] = [];
+
+        colDiffs.forEach(colDiff => {
+          switch (colDiff.actionType) {
+            case 'CREATE':
+              (this.orm.driverInstance as DriverInterface).getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions);
+              break;
+            case 'DELETE':
+              (this.orm.driverInstance as DriverInterface).getDropColumn(colDiffInstructions, schema, tableName, colName);
+              break;
+            case 'ALTER':
+              this.applyColumnChanges(colDiff, colDiffInstructions, schema, tableName, colName);
+              break;
+            case "INDEX":
+              if (colDiff.indexTables) {
+                colDiff.indexTables.forEach(index => {
+                  // if already exists instruction for this index, skip
+                  if (colDiffInstructions.find(instruction => instruction.includes(index.name))) {
+                    return;
+                  }
+
+                  if (this.alreadyConstraint(sqlInstructions, index.name)) {
+                    return;
+                  }
+
+                  if (index.properties) {
+                    colDiffInstructions.push((this.orm.driverInstance as DriverInterface).getCreateIndex(index, schema, tableName));
+                  } else {
+                    colDiffInstructions.push((this.orm.driverInstance as DriverInterface).getDropIndex(index, schema, tableName));
+                  }
+                });
+              }
+              break;
+            // Adicione lógica para outros tipos de ação, se necessário
+          }
+        });
+
+        // Se houver instruções para a coluna, agrupe-as
+        if (colDiffInstructions.length > 0) {
+          sqlInstructions.push(colDiffInstructions.join('\n'));
+        }
+      });
+    });
+    const migrationContent = sqlInstructions.join('\n');
+
+    if (migrationContent.length === 0) {
+      console.log('No changes detected');
+      return;
+    } else {
+      fs.writeFileSync(migrationFilePath, migrationContent);
+
+      console.log(`Migration file created: ${migrationFilePath}`);
+    }
+  }
+
+  async migrate() {
+    const migrationTable = 'cheetah_migrations';
+    const migrationDirectory = path.join(process.cwd(), this.config.migrationPath ?? 'database/migrations');
+    const migrationFiles = fs
+      .readdirSync(migrationDirectory)
+      .filter(file => file.endsWith('.sql'))
+      .sort();
+
+    if (migrationFiles.length === 0) {
+      console.log('No migration files found');
+      return;
+    }
+
+    this.orm.driverInstance.executeSql(`CREATE TABLE IF NOT EXISTS "${migrationTable}" ("migration_file" character varying(255) NOT NULL PRIMARY KEY UNIQUE);`);
+    // get the migration fil
+    const migrated = await this.orm.driverInstance.executeSql(`SELECT * FROM "${migrationTable}" ORDER BY "migration_file" ASC;`);
+    const lastMigration = migrated.rows[migrated.rows.length - 1];
+    const lastMigrationIndex = migrationFiles.indexOf(lastMigration?.migration_file ?? '');
+    const migrationsToExecute = migrationFiles.slice(lastMigrationIndex + 1);
+
+    if (migrationsToExecute.length === 0) {
+      console.log('Database is up to date');
+      return;
+    }
+
+    for (const migrationFile of migrationsToExecute) {
+      const migrationFilePath = path.join(migrationDirectory, migrationFile);
+      const migrationContent = fs.readFileSync(migrationFilePath, {encoding: 'utf-8'});
+      const sqlInstructions = migrationContent.split(';').filter(sql => sql.trim().length > 0);
+
+      for (const sqlInstruction of sqlInstructions) {
+        await this.orm.driverInstance.executeSql(sqlInstruction);
+      }
+
+      await this.orm.driverInstance.executeSql(`INSERT INTO "${migrationTable}" ("migration_file") VALUES ('${migrationFile}');`);
+
+      console.log(`Migration executed: ${migrationFile}`);
+    }
+  }
+
+  private applyColumnChanges(colDiff: ColDiff, sqlInstructions: string[], schema: string | undefined, tableName: string, colName: string) {
+    if (colDiff.colType) {
+      sqlInstructions.push( (this.orm.driverInstance as DriverInterface).getAlterTableType(schema, tableName, colName, colDiff));
+    }
+
+    if (colDiff.colChanges) {
+      if (colDiff.colChanges.default !== undefined) {
+        sqlInstructions.push((this.orm.driverInstance as DriverInterface).getAlterTableDefaultInstruction(schema, tableName, colName, colDiff));
+      }
+
+      if (colDiff.colChanges.primary !== undefined) {
+        if (colDiff.colChanges.primary) {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getAlterTablePrimaryKeyInstruction(schema, tableName, colName, colDiff));
+        } else {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getDropConstraint({name: `${tableName}_pkey`}, schema, tableName));
+        }
+      }
+
+      if (colDiff.colChanges.unique !== undefined && !this.alreadyConstraint(sqlInstructions, `${tableName}_${colName}_key`)) {
+        if (colDiff.colChanges.unique) {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getAddUniqueConstraint(schema, tableName, colName));
+        } else {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getDropConstraint({name: `${tableName}_${colName}_key`}, schema, tableName));
+        }
+      }
+
+      if(colDiff.colChanges.nullable !== undefined) {
+        if (colDiff.colChanges.nullable) {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getAlterTableDropNullInstruction(schema, tableName, colName, colDiff));
+        } else {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getAlterTableDropNotNullInstruction(schema, tableName, colName, colDiff));
+        }
+      }
+
+      if (colDiff.colChanges.foreignKeys !== undefined) {
+        if (colDiff.colChanges.foreignKeys.length === 0) {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getDropConstraint({name: `${tableName}_${colName}_fk`}, schema, tableName));
+        }
+
+        colDiff.colChanges.foreignKeys.forEach(fk => {
+          sqlInstructions.push((this.orm.driverInstance as DriverInterface).getAlterTableFkInstruction(schema, tableName, colDiff, fk))
+        });
+      }
+      // Adicione lógica para outras alterações necessárias
+    }
+  }
+
+  private alreadyConstraint(sqlInstructions: string[], s: string): boolean {
+    return sqlInstructions.some(sql => sql.includes(`"${s}"`));
+  }
+}

package/src/orm.service.ts

@@ -0,0 +1,120 @@
+import { Metadata, OnApplicationInit, Service } from '@cheetah.js/core';
+import { EntityStorage, Property } from './domain/entities';
+import { ENTITIES, PROPERTIES_METADATA, PROPERTIES_RELATIONS } from './constants';
+import { globbySync } from 'globby';
+import { Project, SyntaxKind } from 'ts-morph';
+import { Orm } from './orm';
+
+@Service()
+export class OrmService {
+  private allEntities = new Map<string, { nullables: string[], defaults: { [key: string]: any } }>();
+
+  constructor(private orm: Orm, private storage: EntityStorage, entityFile?: string) {
+    console.log('Preparing entities...')
+    const files = new Project({skipLoadingLibFiles: true}).addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths())
+    files.forEach(file => {
+      file.getClasses().forEach(classDeclaration => {
+        if (classDeclaration.getDecorator('Entity')) {
+
+          const properties = classDeclaration.getProperties();
+          const nullables: string[] = [];
+          const defaults: { [key: string]: any } = {};
+
+          properties.forEach(property => {
+            const propertyName = property.getName();
+            const isNullable = property.hasQuestionToken();
+            const initializer = property.getInitializer();
+            if (isNullable) {
+              nullables.push(propertyName);
+            }
+            if (initializer) {
+              const initializerKind = initializer.getKind();
+
+              switch (initializerKind) {
+                case SyntaxKind.StringLiteral:
+                  defaults[propertyName] = initializer.getText();
+                  break;
+                case SyntaxKind.NumericLiteral:
+                  defaults[propertyName] = parseFloat(initializer.getText());
+                  break;
+                default:
+                  defaults[propertyName] = () => initializer.getText();
+                  break;
+              }
+            }
+
+            this.allEntities.set(classDeclaration.getName() as string, {nullables, defaults});
+          });
+        }
+      });
+    })
+  }
+
+  @OnApplicationInit()
+  async onInit(customConfig: any = {}) {
+
+    const configFile = globbySync('cheetah.config.ts', {absolute: true});
+    if (configFile.length === 0) {
+      console.log('No config file found!')
+      return;
+    }
+
+    const config = await import(configFile[0]);
+    const setConfig = Object.keys(customConfig).length > 0 ? customConfig :  config.default;
+
+    this.orm.setConnection(setConfig);
+    await this.orm.connect();
+
+    if (typeof config.default.entities === 'string') {
+      const files = globbySync([config.default.entities, '!node_modules'], {gitignore: true, absolute: true})
+
+      for (const file of files) {
+        await import(file)
+      }
+    }
+
+    const entities = Metadata.get(ENTITIES, Reflect);
+
+    if (!entities) {
+      console.log('No entities found!')
+      return;
+    }
+
+    for (const entity of entities) {
+      const nullableDefaultEntity = this.allEntities.get(entity.target.name);
+      const properties: { [key: string]: Property } = Metadata.get(PROPERTIES_METADATA, entity.target);
+      const relationship = Metadata.get(PROPERTIES_RELATIONS, entity.target);
+
+      for (const property in properties) {
+        if (nullableDefaultEntity?.nullables.includes(property)) {
+          properties[property].options.nullable = true;
+        }
+        if (nullableDefaultEntity?.defaults[property]) {
+          properties[property].options.default = nullableDefaultEntity?.defaults[property];
+        }
+      }
+
+      this.storage.add(entity, properties, relationship);
+    }
+    console.log('Entities prepared!')
+  }
+
+
+  private getSourceFilePaths(): string[] {
+    const projectRoot = process.cwd(); // Ajuste conforme a estrutura do seu projeto
+
+    const getAllFiles = (dir: string): string[] => {
+      const patterns = [`${dir}/**/*.(ts|js)`, "!**/node_modules/**"];
+
+      try {
+        return globbySync(patterns, {gitignore: true});
+      } catch (error) {
+        console.error('Erro ao obter arquivos:', error);
+        return [];
+      }
+    }
+
+    // Filtra os arquivos pelo padrão de nomenclatura
+    return getAllFiles(projectRoot);
+  }
+}