@cheetah.js/orm 0.1.25 → 0.1.26

package/dist/bun/index.js

@@ -225242,6 +225242,2201 @@ class Uuid extends ValueObject {
     return /^[a-f\d]{8}(-[a-f\d]{4}){4}[a-f\d]{8}$/i.test(value);
   }
 }
+// ../../node_module
+var ENTITIES2 = "cheetah:entities";
+var PROPERTIES_METADATA2 = "cheetah:properties:metadata";
+var PROPERTIES_RELATIONS2 = "cheetah:properties:relations";
+var EVENTS_METADATA2 = "cheetah:events:metadata";
+// ../../node_mo
+function getDefaultLength2(type) {
+  return null;
+}
+// ../../node_modules/bala
+var __decorate9 = function(decorators5, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators5, target, key, desc);
+  else
+    for (var i = decorators5.length - 1;i >= 0; i--)
+      if (d = decorators5[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata7 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var EntityStorage_1;
+var EntityStorage2 = class EntityStorage3 {
+  static {
+    EntityStorage_1 = this;
+  }
+  static instance;
+  entities = new Map;
+  constructor() {
+    EntityStorage_1.instance = this;
+  }
+  add(entity, properties, relations, hooks3) {
+    const entityName = entity.options?.tableName || entity.target.name.toLowerCase();
+    const indexes = Metadata.get("indexes", entity.target) || [];
+    this.entities.set(entity.target, {
+      properties,
+      hideProperties: Object.entries(properties).filter(([key, value]) => value.options.hidden).map(([key]) => key),
+      relations,
+      indexes: indexes.map((index) => {
+        return {
+          table: entityName,
+          indexName: index.name.replace("[TABLE]", entityName),
+          columnName: index.properties.join(",")
+        };
+      }),
+      hooks: hooks3,
+      tableName: entityName,
+      ...entity.options
+    });
+  }
+  get(entity) {
+    return this.entities.get(entity);
+  }
+  entries() {
+    return this.entities.entries();
+  }
+  static getInstance() {
+    return EntityStorage_1.instance;
+  }
+  async snapshot(values) {
+    return {
+      tableName: values.tableName,
+      schema: values.schema || "public",
+      indexes: values.indexes || [],
+      columns: this.snapshotColumns(values)
+    };
+  }
+  snapshotColumns(values) {
+    let properties = Object.entries(values.properties).map(([key, value]) => {
+      return {
+        name: key,
+        type: value.options.dbType ?? value.type.name,
+        nullable: value.options?.nullable,
+        default: value.options?.default,
+        autoIncrement: value.options?.autoIncrement,
+        primary: value.options?.isPrimary,
+        unique: value.options?.unique,
+        length: value.options?.length,
+        isEnum: value.options?.isEnum,
+        enumItems: value.options?.enumItems
+      };
+    });
+    let relations = values.relations && values.relations.map((relation) => {
+      const type = this.getFkType(relation);
+      return {
+        name: relation.propertyKey,
+        type,
+        nullable: relation.nullable,
+        unique: relation.unique,
+        length: relation.length || getDefaultLength2(type),
+        default: relation.default,
+        autoIncrement: relation.autoIncrement,
+        primary: relation.isPrimary,
+        foreignKeys: [
+          {
+            referencedColumnName: this.getFkKey(relation),
+            referencedTableName: this.get(relation.entity()).tableName
+          }
+        ]
+      };
+    });
+    if (!relations) {
+      relations = [];
+    }
+    if (!properties) {
+      properties = [];
+    }
+    return [...properties, ...relations];
+  }
+  snapshotIndexes(values) {
+    return Object.entries(values.properties).map(([key, value]) => {
+      return {
+        indexName: key,
+        columnName: key,
+        table: values.tableName
+      };
+    });
+  }
+  getFkType(relation) {
+    const entity = this.get(relation.entity());
+    if (!entity) {
+      return "unknown";
+    }
+    return entity.properties[this.getFkKey(relation)].type.name;
+  }
+  getFkKey(relationShip) {
+    if (typeof relationShip.fkKey === "undefined") {
+      const entity = this.entities.get(relationShip.entity());
+      const property3 = Object.entries(entity.properties).find(([key, value]) => value.options.isPrimary === true);
+      if (!property3) {
+        throw new Error(`Entity ${entity.tableName} does not have a primary key`);
+      }
+      return property3[0];
+    }
+    if (typeof relationShip.fkKey === "string") {
+      return relationShip.fkKey;
+    }
+    const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
+    return match ? match.groups.propriedade : "";
+  }
+};
+EntityStorage2 = EntityStorage_1 = __decorate9([
+  Service(),
+  __metadata7("design:paramtypes", [])
+], EntityStorage2);
+
+// ../../node_modules/balanced
+class ValueObject2 {
+  value;
+  constructor(value) {
+    if (!this.validate(value)) {
+      throw new HttpException(`Invalid value for ${this.constructor.name}`, 400);
+    }
+    this.setValue(value);
+  }
+  static from(value) {
+    return new this(value);
+  }
+  getValue() {
+    return this.value;
+  }
+  equals(vo) {
+    return this.getValue() === vo.getValue();
+  }
+  setValue(value) {
+    this.value = value;
+  }
+}
+
+// ../../node_modules/balance
+class BaseEntity2 {
+  _oldValues = {};
+  _changedValues = {};
+  $_isPersisted = false;
+  constructor() {
+    return new Proxy(this, {
+      set(target, p, newValue) {
+        if (p.startsWith("$")) {
+          target[p] = newValue;
+          return true;
+        }
+        if (!target._oldValues[p]) {
+          target._oldValues[p] = newValue;
+        }
+        if (target._oldValues[p] !== newValue) {
+          target._changedValues[p] = newValue;
+        }
+        target[p] = newValue;
+        return true;
+      }
+    });
+  }
+  static createQueryBuilder() {
+    return new SqlBuilder5(this);
+  }
+  createQueryBuilder() {
+    return new SqlBuilder5(this.constructor);
+  }
+  static async find(where, options) {
+    return this.createQueryBuilder().select(options?.fields).setStrategy(options?.loadStrategy).load(options?.load).where(where).limit(options?.limit).offset(options?.offset).orderBy(options?.orderBy).executeAndReturnAll();
+  }
+  static async findOne(where, options) {
+    return this.createQueryBuilder().select(options?.fields).setStrategy(options?.loadStrategy).load(options?.load).where(where).executeAndReturnFirst();
+  }
+  static async findOneOrFail(where, options) {
+    return this.createQueryBuilder().select(options?.fields).setStrategy(options?.loadStrategy).load(options?.load).where(where).orderBy(options?.orderBy).executeAndReturnFirstOrFail();
+  }
+  static async findAll(options) {
+    const builder = this.createQueryBuilder().select(options.fields).setStrategy(options?.loadStrategy).load(options?.load).offset(options?.offset).limit(options.limit).orderBy(options?.orderBy);
+    return builder.executeAndReturnAll();
+  }
+  static async create(where) {
+    return this.createQueryBuilder().insert(where).executeAndReturnFirstOrFail();
+  }
+  async save() {
+    const qb = this.createQueryBuilder();
+    if (this.$_isPersisted) {
+      qb.update(this._changedValues);
+      qb.setInstance(this);
+      qb.where({ id: this._oldValues.id });
+    } else {
+      qb.insert(this._oldValues);
+    }
+    await qb.execute();
+    qb.callHook("afterCreate", this);
+    qb.callHook("afterUpdate", this);
+    this._oldValues = {
+      ...this._oldValues,
+      ...this._changedValues
+    };
+    this._changedValues = {};
+  }
+  toJSON() {
+    let data = {};
+    let storage2 = EntityStorage2.getInstance();
+    let entity = storage2.get(this.constructor);
+    let allProperties = new Map(Object.entries(entity.properties).map(([key, value]) => [key, value]));
+    for (const key in this) {
+      if (key.startsWith("$") || key.startsWith("_")) {
+        continue;
+      }
+      if (!allProperties.has(key)) {
+        continue;
+      }
+      if (entity.hideProperties.includes(key)) {
+        continue;
+      }
+      data[key] = this[key];
+    }
+    return data;
+  }
+}
+
+// ../../node_modules
+var processValuesForInsert2 = function(values) {
+  for (const value in values) {
+    if (extendsFrom2(ValueObject2, values[value].constructor.prototype)) {
+      values[value] = values[value].getValue();
+      continue;
+    }
+    if (values[value] instanceof BaseEntity2) {
+      values[value] = values[value].id;
+    }
+  }
+};
+var processValuesForUpdate2 = function(values) {
+  for (const value in values) {
+    if (extendsFrom2(ValueObject2, values[value].constructor.prototype)) {
+      values[value] = values[value].getValue();
+    }
+  }
+};
+var extendsFrom2 = function(baseClass, instance) {
+  let proto = Object.getPrototypeOf(instance);
+  while (proto) {
+    if (proto === baseClass.prototype) {
+      return true;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
+};
+var upEntity2 = function(values, entity, moment = undefined) {
+  const entityStorage = EntityStorage2.getInstance();
+  const entityOptions = entityStorage.get(entity);
+  const instance = new entity;
+  if (!entityOptions) {
+    throw new Error("Entity not found");
+  }
+  const property3 = Object.entries(entityOptions.properties);
+  const relations = entityOptions.relations;
+  property3.forEach(([key, property4]) => {
+    if (property4.options.onInsert && moment === "insert") {
+      instance[key] = property4.options.onInsert();
+    }
+    if (property4.options.onInsert && moment === "update") {
+      instance[key] = property4.options.onUpdate();
+    }
+    if (key in values) {
+      instance[key] = values[key];
+    }
+  });
+  if (relations) {
+    for (const relation of relations) {
+      if (relation.relation === "many-to-one") {
+        instance[relation.propertyKey] = instance[relation.propertyKey];
+      }
+    }
+  }
+  return instance;
+};
+
+class SqlBuilder5 {
+  driver;
+  entityStorage;
+  statements = {};
+  entity;
+  model;
+  aliases = new Set;
+  lastKeyNotOperator = "";
+  logger;
+  updatedColumns = [];
+  originalColumns = [];
+  constructor(model) {
+    const orm6 = Orm2.getInstance();
+    this.driver = orm6.driverInstance;
+    this.logger = orm6.logger;
+    this.entityStorage = EntityStorage2.getInstance();
+    this.getEntity(model);
+    this.statements.hooks = this.entity.hooks;
+  }
+  select(columns) {
+    const tableName = this.entity.tableName || this.model.name.toLowerCase();
+    const schema = this.entity.schema || "public";
+    this.statements.statement = "select";
+    this.statements.columns = columns;
+    this.originalColumns = columns || [];
+    this.statements.alias = this.getAlias(tableName);
+    this.statements.table = `"${schema}"."${tableName}"`;
+    return this;
+  }
+  setStrategy(strategy = "joined") {
+    this.statements.strategy = strategy;
+    return this;
+  }
+  setInstance(instance) {
+    this.statements.instance = instance;
+    return this;
+  }
+  insert(values) {
+    const { tableName, schema } = this.getTableName();
+    processValuesForInsert2(values);
+    this.statements.statement = "insert";
+    this.statements.instance = upEntity2(values, this.model, "insert");
+    this.statements.alias = this.getAlias(tableName);
+    this.statements.table = `"${schema}"."${tableName}"`;
+    this.statements.values = this.withUpdatedValues(this.withDefaultValues(values, this.entity), this.entity);
+    this.reflectToValues();
+    return this;
+  }
+  update(values) {
+    const { tableName, schema } = this.getTableName();
+    processValuesForUpdate2(values);
+    this.statements.statement = "update";
+    this.statements.alias = this.getAlias(tableName);
+    this.statements.table = `${schema}.${tableName}`;
+    this.statements.values = this.withUpdatedValues(values, this.entity);
+    this.statements.instance = upEntity2(values, this.model, "update");
+    return this;
+  }
+  where(where) {
+    if (!where || Object.keys(where).length === 0) {
+      return this;
+    }
+    this.statements.where = this.conditionToSql(where, this.statements.alias, this.model);
+    return this;
+  }
+  orderBy(orderBy) {
+    if (!orderBy) {
+      return this;
+    }
+    this.statements.orderBy = this.objectToStringMap(orderBy);
+    return this;
+  }
+  limit(limit) {
+    this.statements.limit = limit;
+    return this;
+  }
+  offset(offset) {
+    this.statements.offset = offset;
+    return this;
+  }
+  load(load) {
+    load?.forEach((relationshipPath) => {
+      this.addJoinForRelationshipPath(this.entity, relationshipPath);
+    });
+    if (this.statements.join) {
+      this.statements.join = this.statements.join?.reverse();
+    }
+    if (this.statements.selectJoin) {
+      this.statements.selectJoin = this.statements.selectJoin?.reverse();
+    }
+    return this;
+  }
+  addJoinForRelationshipPath(entity, relationshipPath) {
+    const relationshipNames = relationshipPath.split(".");
+    let currentEntity = entity;
+    let currentAlias = this.statements.alias;
+    let statement = this.statements.strategy === "joined" ? this.statements.join : this.statements.selectJoin;
+    let nameAliasProperty = this.statements.strategy === "joined" ? "joinAlias" : "alias";
+    relationshipNames.forEach((relationshipName, index) => {
+      const relationship = currentEntity.relations.find((rel) => rel.propertyKey === relationshipName);
+      if (!relationship) {
+        throw new Error(`Relationship "${relationshipName}" not found in entity "${currentEntity.name}"`);
+      }
+      const isLastRelationship = index === relationshipNames.length - 1;
+      if (index === (relationshipNames.length - 2 >= 0 ? relationshipNames.length - 2 : 0)) {
+        const join = statement?.find((j) => j.joinProperty === relationshipName);
+        if (join) {
+          currentAlias = join[nameAliasProperty];
+        }
+      }
+      if (relationship.relation === "many-to-one" && isLastRelationship) {
+        this.applyJoin(relationship, {}, currentAlias);
+        statement = this.statements.strategy === "joined" ? this.statements.join : this.statements.selectJoin;
+        currentAlias = statement[statement.length - 1][nameAliasProperty];
+      }
+      currentEntity = this.entityStorage.get(relationship.entity());
+    });
+  }
+  getPrimaryKeyColumnName(entity) {
+    return "id";
+  }
+  async execute() {
+    if (!this.statements.columns) {
+      this.statements.columns = this.generateColumns();
+    } else {
+      this.extractAliasForColumns();
+      this.filterInvalidColumns();
+    }
+    this.statements.join = this.statements.join?.reverse();
+    this.includeUpdatedColumns();
+    this.beforeHooks();
+    const result = await this.driver.executeStatement(this.statements);
+    this.logExecution(result);
+    return result;
+  }
+  beforeHooks() {
+    if (this.statements.statement === "update") {
+      this.callHook("beforeUpdate", this.statements.instance);
+      return;
+    }
+    if (this.statements.statement === "insert") {
+      this.callHook("beforeCreate");
+      return;
+    }
+  }
+  afterHooks(model) {
+    if (this.statements.statement === "update") {
+      this.callHook("afterUpdate", this.statements.instance);
+      return;
+    }
+    if (this.statements.statement === "insert") {
+      this.callHook("afterCreate", model);
+      return;
+    }
+  }
+  async executeAndReturnFirst() {
+    this.statements.limit = 1;
+    const result = await this.execute();
+    if (result.query.rows.length === 0) {
+      return;
+    }
+    const entities7 = result.query.rows[0];
+    const model = await this.transformToModel(this.model, this.statements, entities7);
+    this.afterHooks(model);
+    await this.handleSelectJoin(entities7, model);
+    return model;
+  }
+  async executeAndReturnFirstOrFail() {
+    this.statements.limit = 1;
+    const result = await this.execute();
+    if (result.query.rows.length === 0) {
+      throw new Error("Result not found");
+    }
+    const entities7 = result.query.rows[0];
+    const model = await this.transformToModel(this.model, this.statements, entities7);
+    this.afterHooks(model);
+    await this.handleSelectJoin(entities7, model);
+    return model;
+  }
+  async executeAndReturnAll() {
+    const result = await this.execute();
+    if (result.query.rows.length === 0) {
+      return [];
+    }
+    const rows = result.query.rows;
+    const results = [];
+    for (const row of rows) {
+      const models = this.transformToModel(this.model, this.statements, row);
+      this.afterHooks(models);
+      await this.handleSelectJoin(row, models);
+      results.push(models);
+    }
+    return results;
+  }
+  async handleSelectJoin(entities7, models) {
+    if (!this.statements.selectJoin || this.statements.selectJoin.length === 0) {
+      return;
+    }
+    for (const join of this.statements.selectJoin.reverse()) {
+      let ids = entities7[`${join.originAlias}_${join.primaryKey}`];
+      if (typeof ids === "undefined") {
+        const selectJoined = this.statements.selectJoin.find((j) => j.joinEntity === join.originEntity);
+        if (!selectJoined) {
+          continue;
+        }
+        ids = this.findIdRecursively(models, selectJoined, join);
+      }
+      if (Array.isArray(ids)) {
+        ids = ids.map((id) => this.t(id)).join(", ");
+      }
+      if (join.where) {
+        join.where = `${join.where} AND ${join.alias}."${join.fkKey}" IN (${ids})`;
+      } else {
+        join.where = `${join.alias}."${join.fkKey}" IN (${ids})`;
+      }
+      if (join.columns && join.columns.length > 0) {
+        join.columns = join.columns.map((column) => `${join.alias}."${column}" as "${join.alias}_${column}"`);
+      } else {
+        join.columns = this.getColumnsEntity(join.joinEntity, join.alias);
+      }
+      const child = await this.driver.executeStatement(join);
+      this.logger.debug(`SQL: ${child.sql} [${Date.now() - child.startTime}ms]`);
+      const property3 = this.entityStorage.get(this.model).relations.find((rel) => rel.propertyKey === join.joinProperty);
+      const values = child.query.rows.map((row) => this.transformToModel(join.joinEntity, join, row));
+      const path3 = this.getPathForSelectJoin(join);
+      this.setValueByPath(models, path3, property3?.type === Array ? [...values] : values[0]);
+    }
+    return models;
+  }
+  getPathForSelectJoin(selectJoin) {
+    const path3 = this.getPathForSelectJoinRecursive(this.statements, selectJoin);
+    return path3.reverse();
+  }
+  setValueByPath(obj, path3, value) {
+    let currentObj = obj;
+    for (let i = 0;i < path3.length - 1; i++) {
+      const key = path3[i];
+      currentObj[key] = currentObj[key] || {};
+      currentObj = currentObj[key];
+    }
+    currentObj[path3[path3.length - 1]] = value;
+  }
+  getPathForSelectJoinRecursive(statements, selectJoin) {
+    const originJoin = this.statements.selectJoin.find((j) => j.joinEntity === selectJoin.originEntity);
+    let pathInJoin = [];
+    if (!originJoin) {
+      return [selectJoin.joinProperty];
+    }
+    if (originJoin.originEntity !== statements.originEntity) {
+      pathInJoin = this.getPathForSelectJoinRecursive(statements, originJoin);
+    }
+    return [selectJoin.joinProperty, ...pathInJoin];
+  }
+  findIdRecursively(models, selectJoined, join) {
+    let ids = models[selectJoined.originProperty][join.primaryKey];
+    if (typeof ids === "undefined") {
+      const nextSelectJoined = this.statements.selectJoin.find((j) => j.joinEntity === selectJoined.originEntity);
+      if (nextSelectJoined) {
+        ids = this.findIdRecursively(models, nextSelectJoined, join);
+      }
+    }
+    return ids;
+  }
+  generateColumns() {
+    let columns = [
+      ...this.getColumnsEntity(this.model, this.statements.alias)
+    ];
+    if (this.statements.join) {
+      columns = [
+        ...columns,
+        ...this.statements.join.flatMap((join) => this.getColumnsEntity(join.joinEntity, join.joinAlias))
+      ];
+    }
+    return columns;
+  }
+  extractAliasForColumns() {
+    this.statements.columns = this.statements.columns.map((column) => {
+      return this.discoverColumnAlias(column);
+    }).flat();
+  }
+  filterInvalidColumns() {
+    this.statements.columns = this.statements.columns.filter(Boolean);
+  }
+  includeUpdatedColumns() {
+    this.statements.columns.push(...this.updatedColumns);
+  }
+  logExecution(result) {
+    this.logger.debug(`SQL: ${result.sql} [${Date.now() - result.startTime}ms]`);
+  }
+  startTransaction() {
+    return this.driver.startTransaction();
+  }
+  commit() {
+    return this.driver.commitTransaction();
+  }
+  rollback() {
+    return this.driver.rollbackTransaction();
+  }
+  async inTransaction(callback) {
+    await this.startTransaction();
+    try {
+      const result = await callback(this);
+      await this.commit();
+      return result;
+    } catch (e) {
+      await this.rollback();
+      throw e;
+    }
+  }
+  objectToStringMap(obj, parentKey = "") {
+    let result = [];
+    for (let key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        let fullKey = parentKey ? `${parentKey}.${key}` : key;
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+          result = result.concat(this.objectToStringMap(obj[key], fullKey));
+        } else {
+          result.push(`${this.discoverColumnAlias(fullKey, true)} ${obj[key]}`);
+        }
+      }
+    }
+    return result;
+  }
+  discoverColumnAlias(column, onlyAlias = false) {
+    if (!column.includes(".")) {
+      if (onlyAlias) {
+        return `${this.statements.alias}."${column}"`;
+      }
+      return `${this.statements.alias}."${column}" as ${this.statements.alias}_${column}`;
+    }
+    if (typeof this.statements.join === "undefined" && typeof this.statements.selectJoin === "undefined") {
+      throw new Error("Join not found");
+    }
+    const entities7 = column.split(".");
+    let lastEntity = this.model;
+    let lastAlias = this.statements.alias;
+    const relationsMap = new Map(this.entity.relations.map((rel) => [rel.propertyKey, rel]));
+    const joinMap = new Map;
+    const joinSelectMap = new Map;
+    this.statements.join?.forEach((join) => joinMap.set(join.joinProperty, join));
+    this.statements.selectJoin?.forEach((join) => joinSelectMap.set(join.joinProperty, join));
+    for (let i = 0;i < entities7.length; i++) {
+      if (i === 0) {
+        const relation = relationsMap.get(entities7[i]);
+        lastEntity = relation?.entity();
+        if (joinMap.has(entities7[i])) {
+          lastAlias = joinMap.get(entities7[i]).joinAlias;
+        } else {
+          lastAlias = joinSelectMap.get(entities7[i])?.alias;
+          return;
+        }
+      } else {
+        if (i + 1 === entities7.length) {
+          if (onlyAlias) {
+            return `${lastAlias}."${entities7[i]}"`;
+          }
+          return `${lastAlias}."${entities7[i]}" as ${lastAlias}_${entities7[i]}`;
+        }
+        const lastStatement = joinMap.get(entities7[i]);
+        lastEntity = lastStatement?.joinEntity;
+        lastAlias = lastStatement?.joinAlias;
+      }
+    }
+    return "";
+  }
+  getTableName() {
+    const tableName = this.entity.tableName || this.model.name.toLowerCase();
+    const schema = this.entity.schema || "public";
+    return { tableName, schema };
+  }
+  addSimpleConditionToSql(key, value, alias = null, operator = "=") {
+    const aliasToUse = alias || this.statements.alias;
+    const valueByType = typeof value === "string" ? `'${value}'` : value;
+    return `${aliasToUse}.${key} ${operator} ${valueByType}`;
+  }
+  addInConditionToSql(key, values, alias = null) {
+    const aliasToUse = alias || this.statements.alias;
+    return `${aliasToUse}.${key} IN (${values.map((val) => typeof val === "string" ? `'${val}'` : val).join(", ")})`;
+  }
+  addLogicalOperatorToSql(conditions, operator) {
+    return `(${conditions.join(` ${operator} `)})`;
+  }
+  conditionToSql(condition, alias, model) {
+    const sqlParts = [];
+    const operators = ["$eq", "$ne", "$in", "$nin", "$like", "$gt", "$gte", "$lt", "$lte", "$and", "$or"];
+    for (let [key, value] of Object.entries(condition)) {
+      if (this.extendsFrom(ValueObject2, value.constructor.prototype)) {
+        value = value.getValue();
+      }
+      if (!operators.includes(key)) {
+        this.lastKeyNotOperator = key;
+      }
+      const entity = this.entityStorage.get(model);
+      const relationShip = entity.relations?.find((rel) => rel.propertyKey === key);
+      if (relationShip) {
+        const sql = this.applyJoin(relationShip, value, alias);
+        if (this.statements.strategy === "joined") {
+          sqlParts.push(sql);
+        }
+      } else if (typeof value !== "object" || value === null) {
+        if (key === "$eq") {
+          sqlParts.push(this.addSimpleConditionToSql(this.lastKeyNotOperator, value, alias, "="));
+          continue;
+        }
+        sqlParts.push(this.addSimpleConditionToSql(key, value, alias));
+      } else if (!operators.includes(key) && Array.isArray(value)) {
+        sqlParts.push(this.addInConditionToSql(key, value, alias));
+      } else {
+        if (["$or", "$and"].includes(key)) {
+          sqlParts.push(this.addLogicalOperatorToSql(value.map((cond) => this.conditionToSql(cond, alias, model)), key.toUpperCase().replace("$", "")));
+        }
+        for (const operator of operators) {
+          if (operator in value) {
+            switch (operator) {
+              case "$eq":
+                sqlParts.push(this.addSimpleConditionToSql(key, value["$eq"], alias, "="));
+                break;
+              case "$ne":
+                sqlParts.push(this.addSimpleConditionToSql(key, value["$ne"], alias, "!="));
+                break;
+              case "$in":
+                sqlParts.push(this.addInConditionToSql(key, value["$in"], alias));
+                break;
+              case "$nin":
+                sqlParts.push(`${alias}.${key} NOT IN (${value["$nin"].map((val) => this.t(val)).join(", ")})`);
+                break;
+              case "$like":
+                sqlParts.push(`${alias}.${key} LIKE '${value["$like"]}'`);
+                break;
+              case "$gt":
+                sqlParts.push(`${alias}.${key} > ${value["$gt"]}`);
+                break;
+              case "$gte":
+                sqlParts.push(`${alias}.${key} >= ${value["$gte"]}`);
+                break;
+              case "$lt":
+                sqlParts.push(`${alias}.${key} < ${value["$lt"]}`);
+                break;
+              case "$lte":
+                sqlParts.push(`${alias}.${key} <= ${value["$lte"]}`);
+                break;
+              case "$and":
+              case "$or":
+                const parts = value[operator].map((cond) => this.conditionToSql(cond, alias, model));
+                sqlParts.push(this.addLogicalOperatorToSql(parts, operator.toUpperCase().replace("$", "")));
+                break;
+            }
+          }
+        }
+      }
+    }
+    if (sqlParts.length === 0) {
+      return "";
+    }
+    return this.addLogicalOperatorToSql(sqlParts, "AND");
+  }
+  t(value) {
+    return typeof value === "string" ? `'${value}'` : value;
+  }
+  applyJoin(relationShip, value, alias) {
+    const { tableName, schema } = this.getTableName();
+    const { tableName: joinTableName, schema: joinSchema, hooks: joinHooks } = this.entityStorage.get(relationShip.entity()) || {
+      tableName: relationShip.entity().name.toLowerCase(),
+      schema: "public"
+    };
+    let originPrimaryKey = "id";
+    for (const prop in this.entity.properties) {
+      if (this.entity.properties[prop].options.isPrimary) {
+        originPrimaryKey = prop;
+        break;
+      }
+    }
+    const joinAlias = `${this.getAlias(joinTableName)}`;
+    const joinWhere = this.conditionToSql(value, joinAlias, relationShip.entity());
+    let on = "";
+    switch (relationShip.relation) {
+      case "one-to-many":
+        on = `${joinAlias}."${this.getFkKey(relationShip)}" = ${alias}."${originPrimaryKey}"`;
+        break;
+      case "many-to-one":
+        on = `${alias}."${relationShip.propertyKey}" = ${joinAlias}."${this.getFkKey(relationShip)}"`;
+        break;
+    }
+    if (this.statements.strategy === "joined") {
+      this.statements.join = this.statements.join || [];
+      this.statements.join.push({
+        joinAlias,
+        joinTable: joinTableName,
+        joinSchema: joinSchema || "public",
+        joinWhere,
+        joinProperty: relationShip.propertyKey,
+        originAlias: alias,
+        originSchema: schema,
+        originTable: tableName,
+        propertyKey: relationShip.propertyKey,
+        joinEntity: relationShip.entity(),
+        type: "LEFT",
+        on,
+        originalEntity: relationShip.originalEntity,
+        hooks: joinHooks
+      });
+    } else {
+      this.statements.selectJoin = this.statements.selectJoin || [];
+      this.statements.selectJoin.push({
+        statement: "select",
+        columns: this.originalColumns.filter((column) => column.startsWith(`${relationShip.propertyKey}`)).map((column) => column.split(".")[1]) || [],
+        table: `"${joinSchema || "public"}"."${joinTableName}"`,
+        alias: joinAlias,
+        where: joinWhere,
+        joinProperty: relationShip.propertyKey,
+        fkKey: this.getFkKey(relationShip),
+        primaryKey: originPrimaryKey,
+        originAlias: alias,
+        originProperty: relationShip.propertyKey,
+        joinEntity: relationShip.entity(),
+        originEntity: relationShip.originalEntity,
+        hooks: joinHooks
+      });
+    }
+    return joinWhere;
+  }
+  getFkKey(relationShip) {
+    if (typeof relationShip.fkKey === "undefined") {
+      return "id";
+    }
+    if (typeof relationShip.fkKey === "string") {
+      return relationShip.fkKey;
+    }
+    const match = /\.(?<propriedade>[\w]+)/.exec(relationShip.fkKey.toString());
+    return match ? match.groups.propriedade : "";
+  }
+  getEntity(model) {
+    const entity = this.entityStorage.get(model);
+    this.model = model;
+    if (!entity) {
+      throw new Error("Entity not found");
+    }
+    this.entity = entity;
+  }
+  transformToModel(model, statement, data) {
+    const instance = new model;
+    instance.$_isPersisted = true;
+    const entitiesByAlias = {
+      [statement.alias]: instance
+    };
+    const entitiesOptions = new Map;
+    entitiesOptions.set(statement.alias, this.entityStorage.get(instance.constructor));
+    if (this.statements.join) {
+      this.statements.join.forEach((join) => {
+        const joinInstance = new join.joinEntity;
+        joinInstance.$_isPersisted = true;
+        entitiesByAlias[join.joinAlias] = joinInstance;
+        entitiesOptions.set(join.joinAlias, this.entityStorage.get(joinInstance.constructor));
+      });
+    }
+    Object.entries(data).forEach(([key, value]) => {
+      const [alias, prop] = key.split("_");
+      const entity = entitiesByAlias[alias];
+      if (!entity) {
+        return;
+      }
+      const entityProperty = entitiesOptions.get(alias).properties[prop];
+      if (entityProperty) {
+        if (this.extendsFrom(ValueObject2, entityProperty.type.prototype)) {
+          entity[prop] = new entityProperty.type(value);
+          return;
+        }
+        entity[prop] = value;
+      }
+    });
+    if (this.statements.join) {
+      this.statements.join.forEach((join) => {
+        const { joinAlias, originAlias, propertyKey } = join;
+        const originEntity = entitiesByAlias[originAlias];
+        const joinEntity = entitiesByAlias[joinAlias];
+        const property3 = entitiesOptions.get(originAlias).relations.find((rel) => rel.propertyKey === propertyKey);
+        if (!originEntity || !joinEntity) {
+          return;
+        }
+        originEntity[propertyKey] = property3.type === Array ? originEntity[propertyKey] ? [...originEntity[propertyKey], joinEntity] : [joinEntity] : joinEntity;
+      });
+    }
+    return instance;
+  }
+  getAlias(tableName) {
+    const alias = tableName.split("").shift() || "";
+    let counter = 1;
+    let uniqueAlias = `${alias}${counter}`;
+    while (this.aliases.has(uniqueAlias)) {
+      counter++;
+      uniqueAlias = `${alias}${counter}`;
+    }
+    this.aliases.add(uniqueAlias);
+    return uniqueAlias;
+  }
+  getColumnsEntity(entity, alias) {
+    const e = this.entityStorage.get(entity);
+    if (!e) {
+      throw new Error("Entity not found");
+    }
+    const columns = Object.keys(e.properties).map((key) => `${alias}."${key}" as "${alias}_${key}"`);
+    if (e.relations) {
+      for (const relation of e.relations) {
+        if (relation.relation === "many-to-one") {
+          columns.push(`${alias}."${relation.propertyKey}" as "${alias}_${relation.propertyKey}"`);
+        }
+      }
+    }
+    return columns;
+  }
+  withDefaultValues(values, entityOptions) {
+    const property3 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
+    const defaultProperties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.default);
+    for (const [key, property4] of defaultProperties) {
+      if (typeof values[key] === "undefined") {
+        if (typeof property4.options.default === "function") {
+          values[key] = (0, eval)(property4.options.default());
+        } else {
+          values[key] = (0, eval)(property4.options.default);
+        }
+      }
+    }
+    property3.forEach(([key, property4]) => {
+      values[key] = property4.options.onInsert();
+      this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
+    });
+    return values;
+  }
+  withUpdatedValues(values, entityOptions) {
+    const property3 = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
+    property3.forEach(([key, property4]) => {
+      values[key] = property4.options.onUpdate();
+      this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
+    });
+    return values;
+  }
+  extendsFrom(baseClass, instance) {
+    if (!instance)
+      return false;
+    let proto = Object.getPrototypeOf(instance);
+    while (proto) {
+      if (proto === baseClass.prototype) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+  }
+  callHook(type, model) {
+    const hooks3 = this.statements.hooks?.filter((hook) => hook.type === type) || [];
+    const instance = model || this.statements.instance;
+    for (const hook of hooks3) {
+      instance[hook.propertyName]();
+      if (!model) {
+        this.reflectToValues();
+      }
+    }
+  }
+  reflectToValues() {
+    for (const key in this.statements.instance) {
+      if (key.startsWith("$")) {
+        continue;
+      }
+      if (key.startsWith("_")) {
+        continue;
+      }
+      if (this.entity.properties[key]) {
+        this.statements.values[key] = this.statements.instance[key];
+        continue;
+      }
+      if (this.entity.relations.find((rel) => rel.propertyKey === key)) {
+        this.statements.values[key] = this.statements.instance[key];
+      }
+    }
+  }
+}
+
+// ../../node_
+var __decorate10 = function(decorators5, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators5, target, key, desc);
+  else
+    for (var i = decorators5.length - 1;i >= 0; i--)
+      if (d = decorators5[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata8 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var Orm_1;
+var Orm2 = class Orm3 {
+  static {
+    Orm_1 = this;
+  }
+  logger;
+  driverInstance;
+  static instance;
+  connection;
+  constructor(logger3) {
+    this.logger = logger3;
+    Orm_1.instance = this;
+  }
+  static getInstance() {
+    return Orm_1.instance;
+  }
+  setConnection(connection) {
+    this.connection = connection;
+    this.driverInstance = new this.connection.driver(connection);
+  }
+  createQueryBuilder(model) {
+    return new SqlBuilder5(model);
+  }
+  connect() {
+    return this.driverInstance.connect();
+  }
+  disconnect() {
+    return this.driverInstance.disconnect();
+  }
+};
+Orm2 = Orm_1 = __decorate10([
+  Service(),
+  __metadata8("design:paramtypes", [LoggerService])
+], Orm2);
+// ../../node_modules/
+var import_ts_morph2 = __toESM(require_ts_morph(), 1);
+var __decorate11 = function(decorators5, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators5, target, key, desc);
+  else
+    for (var i = decorators5.length - 1;i >= 0; i--)
+      if (d = decorators5[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata9 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var OrmService2 = class OrmService3 {
+  orm;
+  storage;
+  allEntities = new Map;
+  constructor(orm7, storage2, entityFile) {
+    this.orm = orm7;
+    this.storage = storage2;
+    console.log("Preparing entities...");
+    const files = new import_ts_morph2.Project({ skipLoadingLibFiles: true }).addSourceFilesAtPaths(entityFile ?? this.getSourceFilePaths());
+    files.forEach((file) => {
+      file.getClasses().forEach((classDeclaration) => {
+        if (classDeclaration.getDecorator("Entity")) {
+          const properties = classDeclaration.getProperties();
+          const nullables = [];
+          const defaults = {};
+          const extendsClass = classDeclaration.getBaseClass();
+          if (extendsClass) {
+            const extendsProperties = extendsClass.getProperties();
+            properties.push(...extendsProperties);
+          }
+          properties.forEach((property3) => {
+            const propertyName = property3.getName();
+            const isNullable = property3.hasQuestionToken();
+            const initializer = property3.getInitializer();
+            if (isNullable) {
+              nullables.push(propertyName);
+            }
+            if (initializer) {
+              const initializerKind = initializer.getKind();
+              switch (initializerKind) {
+                case import_ts_morph2.SyntaxKind.StringLiteral:
+                  defaults[propertyName] = initializer.getText();
+                  break;
+                case import_ts_morph2.SyntaxKind.NumericLiteral:
+                  defaults[propertyName] = parseFloat(initializer.getText());
+                  break;
+                case import_ts_morph2.SyntaxKind.NewExpression:
+                case import_ts_morph2.SyntaxKind.CallExpression:
+                  break;
+                default:
+                  defaults[propertyName] = () => initializer.getText();
+                  break;
+              }
+            }
+            this.allEntities.set(classDeclaration.getName(), { nullables, defaults });
+          });
+        }
+      });
+    });
+  }
+  async onInit(customConfig = {}) {
+    const configFile = globbySync2("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 = globbySync2([config.default.entities, "!node_modules"], { gitignore: true, absolute: true });
+      for (const file of files) {
+        await import(file);
+      }
+    }
+    const entities8 = Metadata.get(ENTITIES2, Reflect);
+    if (!entities8) {
+      console.log("No entities found!");
+      return;
+    }
+    for (const entity of entities8) {
+      const nullableDefaultEntity = this.allEntities.get(entity.target.name);
+      const properties = Metadata.get(PROPERTIES_METADATA2, entity.target);
+      const relationship = Metadata.get(PROPERTIES_RELATIONS2, entity.target);
+      const hooks3 = Metadata.get(EVENTS_METADATA2, entity.target);
+      for (const property3 in properties) {
+        if (nullableDefaultEntity?.nullables.includes(property3)) {
+          properties[property3].options.nullable = true;
+        }
+        if (nullableDefaultEntity?.defaults[property3]) {
+          properties[property3].options.default = nullableDefaultEntity?.defaults[property3];
+        }
+      }
+      this.storage.add(entity, properties, relationship, hooks3);
+    }
+    console.log("Entities prepared!");
+  }
+  getSourceFilePaths() {
+    const projectRoot = process.cwd();
+    const getAllFiles = (dir) => {
+      const patterns = [`${dir}/**/*.(ts|js)`, "!**/node_modules/**"];
+      try {
+        return globbySync2(patterns, { gitignore: true });
+      } catch (error) {
+        console.error("Erro ao obter arquivos:", error);
+        return [];
+      }
+    };
+    return getAllFiles(projectRoot);
+  }
+};
+__decorate11([
+  OnApplicationInit(),
+  __metadata9("design:type", Function),
+  __metadata9("design:paramtypes", [Object]),
+  __metadata9("design:returntype", Promise)
+], OrmService2.prototype, "onInit", null);
+OrmService2 = __decorate11([
+  Service(),
+  __metadata9("design:paramtypes", [Orm2, EntityStorage2, String])
+], OrmService2);
+// ../../node_modules/balan
+var import_pg2 = __toESM(require_lib2(), 1);
+// ../../node_mo
+var CheetahOrm2 = new Cheetah({ exports: [Orm2, OrmService2, EntityStorage2] });
+// ../../node_modules/balance
+import * as path3 from "path";
+import * as fs5 from "fs";
+
+// ../../node_modules/balanced-match
+class DiffCalculator {
+  entities;
+  constructor(entities9) {
+    this.entities = entities9;
+  }
+  diff(snapshotBd, snapshotEntities) {
+    let diffs = [];
+    const bdTablesMap = new Map(snapshotBd.map((table) => [table.tableName, table]));
+    const entityTablesMap = new Map(snapshotEntities.map((table) => [table.tableName, table]));
+    const allTableNames = new Set([...bdTablesMap.keys(), ...entityTablesMap.keys()]);
+    allTableNames.forEach((tableName) => {
+      const bdTable = bdTablesMap.get(tableName);
+      const entityTable = entityTablesMap.get(tableName);
+      if (!entityTable) {
+        diffs.push({
+          tableName,
+          colDiffs: [{ actionType: "DELETE", colName: "*" }]
+        });
+      } else if (!bdTable) {
+        const colDiffs = entityTable.columns.flatMap((c) => {
+          return this.createNewColumn(c, []);
+        });
+        diffs.push({
+          tableName,
+          newTable: true,
+          schema: entityTable.schema ?? "public",
+          colDiffs
+        });
+        this.checkIndexes(bdTable, entityTable, colDiffs);
+      } else {
+        const colDiffs = [];
+        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()]);
+        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,
+            schema: entityTable.schema ?? "public",
+            colDiffs
+          });
+        }
+        this.checkIndexes(bdTable, entityTable, colDiffs);
+      }
+    });
+    return diffs;
+  }
+  checkIndexes(bdTable, entityTable, colDiffs) {
+    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(",") }]
+          });
+        }
+      });
+    }
+  }
+  createNewColumn(entityCol, colDiffs) {
+    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,
+        enumItems: entityCol.enumItems,
+        foreignKeys: entityCol.foreignKeys ?? []
+      }
+    });
+    return colDiffs;
+  }
+  diffColumnType(bdCol, entityCol, colDiffs) {
+    if (bdCol.type === "integer" && bdCol.primary) {
+      bdCol.type = "numeric";
+      bdCol.length = 11;
+    }
+    const colT = entityCol.isEnum ? { type: "USER-DEFINED", len: null } : this.convertEntityTypeToSqlType(entityCol.type);
+    const colType = colT.type;
+    const length = entityCol.length ?? colT.len;
+    if (bdCol.type !== colType || bdCol.length !== length) {
+      if (colType === "USER-DEFINED") {
+        colDiffs.push({
+          actionType: "DELETE",
+          colName: entityCol.name
+        });
+        return;
+      }
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colType,
+        colLength: length
+      });
+    }
+  }
+  diffColumnDefault(bdCol, entityCol, colDiffs) {
+    if (bdCol.default !== entityCol.default) {
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colChanges: { default: entityCol.default },
+        colLength: entityCol.length
+      });
+    }
+  }
+  diffColumnPrimary(bdCol, entityCol, colDiffs) {
+    if (bdCol.primary !== entityCol.primary) {
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colChanges: { primary: entityCol.primary },
+        colLength: entityCol.length
+      });
+    }
+  }
+  diffColumnUnique(bdCol, entityCol, colDiffs) {
+    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
+      });
+    }
+  }
+  diffForeignKey(bdCol, entityCol, colDiffs) {
+    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) => fk !== bdFK)
+            }
+          });
+        }
+      });
+    }
+  }
+  diffColumnSql(bdCol, entityCol, colDiffs) {
+    this.diffForeignKey(bdCol, entityCol, colDiffs);
+    this.diffEnum(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;
+  }
+  diffColumnNullable(bdCol, entityCol, colDiffs) {
+    if (bdCol.nullable !== entityCol.nullable) {
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colChanges: { nullable: entityCol.nullable },
+        colLength: entityCol.length
+      });
+    }
+  }
+  convertEntityTypeToSqlType(entityType) {
+    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 };
+    }
+  }
+  diffEnum(bdCol, entityCol, colDiffs) {
+    if (bdCol.enumItems || entityCol.enumItems) {
+      if (bdCol.enumItems && entityCol.enumItems) {
+        const allEnums = new Set([...bdCol.enumItems, ...entityCol.enumItems]);
+        const differences = [...allEnums].filter((x) => !bdCol.enumItems?.includes(x) || !entityCol.enumItems?.includes(x));
+        if (differences.length === 0) {
+          return;
+        }
+        colDiffs.push({
+          actionType: "ALTER",
+          colName: entityCol.name,
+          colChanges: {
+            enumItems: entityCol.enumItems
+          }
+        });
+      }
+      if (!entityCol.enumItems) {
+        colDiffs.push({
+          actionType: "DELETE",
+          colName: bdCol.name,
+          colChanges: {
+            enumItems: []
+          }
+        });
+      } else if (!bdCol.enumItems) {
+        colDiffs.push({
+          actionType: "CREATE",
+          colName: entityCol.name,
+          colChanges: {
+            enumItems: entityCol.enumItems
+          }
+        });
+      }
+    }
+  }
+}
+
+// ../../node_modules/balance
+class Migrator {
+  config;
+  orm;
+  entities = new EntityStorage2;
+  constructor() {
+    this.orm = Orm2.getInstance();
+    if (this.orm === undefined)
+      this.orm = new Orm2(new LoggerService(new InjectorService));
+    this.entities = EntityStorage2.getInstance();
+    if (this.entities === undefined)
+      this.entities = new EntityStorage2;
+  }
+  async initConfigFile(basePath = process.cwd()) {
+    const paths = await globby2(["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 paths2 = await globby2(this.config.entities, { absolute: true, cwd: basePath });
+      for (const path4 of paths2) {
+        await import(path4);
+      }
+    }
+    const serv = new OrmService2(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);
+  }
+  async snapshotBd() {
+    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;
+  }
+  async snapshotEntities() {
+    const snapshot = [];
+    for (let [_, values] of this.entities.entries()) {
+      snapshot.push(await this.entities.snapshot(values));
+    }
+    return snapshot;
+  }
+  async createMigration(forceName = null) {
+    const diff = await this.initMigration();
+    const migrationDirectory = path3.join(process.cwd(), this.config.migrationPath ?? "database/migrations");
+    const migrationFileName = (forceName ?? `migration_${new Date().toISOString().replace(/[^\d]/g, "")}`) + `.sql`;
+    const migrationFilePath = path3.join(migrationDirectory, migrationFileName);
+    if (!fs5.existsSync(migrationDirectory)) {
+      fs5.mkdirSync(migrationDirectory, { recursive: true });
+    }
+    let sqlInstructions = [];
+    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;
+      }
+      const colChangesMap = new Map;
+      tableDiff.colDiffs.reverse().forEach((colDiff) => {
+        const colName = colDiff.colName;
+        if (!colChangesMap.has(colName)) {
+          colChangesMap.set(colName, []);
+        }
+        colChangesMap.get(colName)?.push(colDiff);
+      });
+      colChangesMap.forEach((colDiffs, colName) => {
+        const colDiffInstructions = [];
+        colDiffs.forEach((colDiff) => {
+          switch (colDiff.actionType) {
+            case "CREATE":
+              this.orm.driverInstance.getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions);
+              break;
+            case "DELETE":
+              if (colDiff.colChanges?.enumItems && colDiff.colChanges?.enumItems.length === 0) {
+                colDiffInstructions.push(this.orm.driverInstance.getDropTypeEnumInstruction({ name: `${schema}_${tableName}_${colName}_enum` }, schema, tableName));
+                return;
+              }
+              this.orm.driverInstance.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 (colDiffInstructions.find((instruction) => instruction.includes(index.name))) {
+                    return;
+                  }
+                  if (this.alreadyConstraint(sqlInstructions, index.name)) {
+                    return;
+                  }
+                  if (index.properties) {
+                    colDiffInstructions.push(this.orm.driverInstance.getCreateIndex(index, schema, tableName));
+                  } else {
+                    colDiffInstructions.push(this.orm.driverInstance.getDropIndex(index, schema, tableName));
+                  }
+                });
+              }
+              break;
+          }
+        });
+        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 {
+      fs5.writeFileSync(migrationFilePath, migrationContent);
+      console.log(`Migration file created: ${migrationFilePath}`);
+    }
+  }
+  async migrate() {
+    const migrationTable = "cheetah_migrations";
+    const migrationDirectory = path3.join(process.cwd(), this.config.migrationPath ?? "database/migrations");
+    const migrationFiles = fs5.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);`);
+    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 = path3.join(migrationDirectory, migrationFile);
+      const migrationContent = fs5.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}`);
+    }
+  }
+  applyColumnChanges(colDiff, sqlInstructions, schema, tableName, colName) {
+    if (colDiff.colType) {
+      sqlInstructions.push(this.orm.driverInstance.getAlterTableType(schema, tableName, colName, colDiff));
+    }
+    if (colDiff.colChanges?.enumItems) {
+      sqlInstructions.push(this.orm.driverInstance.getAlterTableEnumInstruction(schema, tableName, colName, colDiff));
+    }
+    if (colDiff.colChanges) {
+      if (colDiff.colChanges.default !== undefined) {
+        sqlInstructions.push(this.orm.driverInstance.getAlterTableDefaultInstruction(schema, tableName, colName, colDiff));
+      }
+      if (colDiff.colChanges.primary !== undefined) {
+        if (colDiff.colChanges.primary) {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTablePrimaryKeyInstruction(schema, tableName, colName, colDiff));
+        } else {
+          sqlInstructions.push(this.orm.driverInstance.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.getAddUniqueConstraint(schema, tableName, colName));
+        } else {
+        }
+      }
+      if (colDiff.colChanges.nullable !== undefined) {
+        if (colDiff.colChanges.nullable) {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTableDropNullInstruction(schema, tableName, colName, colDiff));
+        } else {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTableDropNotNullInstruction(schema, tableName, colName, colDiff));
+        }
+      }
+      if (colDiff.colChanges.foreignKeys !== undefined) {
+        if (colDiff.colChanges.foreignKeys.length === 0) {
+          sqlInstructions.push(this.orm.driverInstance.getDropConstraint({ name: `${tableName}_${colName}_fk` }, schema, tableName));
+        }
+        colDiff.colChanges.foreignKeys.forEach((fk) => {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTableFkInstruction(schema, tableName, colDiff, fk));
+        });
+      }
+    }
+  }
+  alreadyConstraint(sqlInstructions, s) {
+    return sqlInstructions.some((sql) => sql.includes(`"${s}"`));
+  }
+}
+// ../../node_modules/balanc
+import * as path4 from "path";
+import * as fs6 from "fs";
+
+// ../../node_modules/balanced-matc
+class DiffCalculator2 {
+  entities;
+  constructor(entities10) {
+    this.entities = entities10;
+  }
+  diff(snapshotBd, snapshotEntities) {
+    let diffs = [];
+    const bdTablesMap = new Map(snapshotBd.map((table) => [table.tableName, table]));
+    const entityTablesMap = new Map(snapshotEntities.map((table) => [table.tableName, table]));
+    const allTableNames = new Set([...bdTablesMap.keys(), ...entityTablesMap.keys()]);
+    allTableNames.forEach((tableName) => {
+      const bdTable = bdTablesMap.get(tableName);
+      const entityTable = entityTablesMap.get(tableName);
+      if (!entityTable) {
+        diffs.push({
+          tableName,
+          colDiffs: [{ actionType: "DELETE", colName: "*" }]
+        });
+      } else if (!bdTable) {
+        const colDiffs = entityTable.columns.flatMap((c) => {
+          return this.createNewColumn(c, []);
+        });
+        diffs.push({
+          tableName,
+          newTable: true,
+          schema: entityTable.schema ?? "public",
+          colDiffs
+        });
+        this.checkIndexes(bdTable, entityTable, colDiffs);
+      } else {
+        const colDiffs = [];
+        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()]);
+        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,
+            schema: entityTable.schema ?? "public",
+            colDiffs
+          });
+        }
+        this.checkIndexes(bdTable, entityTable, colDiffs);
+      }
+    });
+    return diffs;
+  }
+  checkIndexes(bdTable, entityTable, colDiffs) {
+    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(",") }]
+          });
+        }
+      });
+    }
+  }
+  createNewColumn(entityCol, colDiffs) {
+    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,
+        enumItems: entityCol.enumItems,
+        foreignKeys: entityCol.foreignKeys ?? []
+      }
+    });
+    return colDiffs;
+  }
+  diffColumnType(bdCol, entityCol, colDiffs) {
+    if (bdCol.type === "integer" && bdCol.primary) {
+      bdCol.type = "numeric";
+      bdCol.length = 11;
+    }
+    const colT = entityCol.isEnum ? { type: "USER-DEFINED", len: null } : this.convertEntityTypeToSqlType(entityCol.type);
+    const colType = colT.type;
+    const length = entityCol.length ?? colT.len;
+    if (bdCol.type !== colType || bdCol.length !== length) {
+      if (colType === "USER-DEFINED") {
+        colDiffs.push({
+          actionType: "DELETE",
+          colName: entityCol.name
+        });
+        return;
+      }
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colType,
+        colLength: length
+      });
+    }
+  }
+  diffColumnDefault(bdCol, entityCol, colDiffs) {
+    if (bdCol.default !== entityCol.default) {
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colChanges: { default: entityCol.default },
+        colLength: entityCol.length
+      });
+    }
+  }
+  diffColumnPrimary(bdCol, entityCol, colDiffs) {
+    if (bdCol.primary !== entityCol.primary) {
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colChanges: { primary: entityCol.primary },
+        colLength: entityCol.length
+      });
+    }
+  }
+  diffColumnUnique(bdCol, entityCol, colDiffs) {
+    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
+      });
+    }
+  }
+  diffForeignKey(bdCol, entityCol, colDiffs) {
+    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) => fk !== bdFK)
+            }
+          });
+        }
+      });
+    }
+  }
+  diffColumnSql(bdCol, entityCol, colDiffs) {
+    this.diffForeignKey(bdCol, entityCol, colDiffs);
+    this.diffEnum(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;
+  }
+  diffColumnNullable(bdCol, entityCol, colDiffs) {
+    if (bdCol.nullable !== entityCol.nullable) {
+      colDiffs.push({
+        actionType: "ALTER",
+        colName: entityCol.name,
+        colChanges: { nullable: entityCol.nullable },
+        colLength: entityCol.length
+      });
+    }
+  }
+  convertEntityTypeToSqlType(entityType) {
+    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 };
+    }
+  }
+  diffEnum(bdCol, entityCol, colDiffs) {
+    if (bdCol.enumItems || entityCol.enumItems) {
+      if (bdCol.enumItems && entityCol.enumItems) {
+        const allEnums = new Set([...bdCol.enumItems, ...entityCol.enumItems]);
+        const differences = [...allEnums].filter((x) => !bdCol.enumItems?.includes(x) || !entityCol.enumItems?.includes(x));
+        if (differences.length === 0) {
+          return;
+        }
+        colDiffs.push({
+          actionType: "ALTER",
+          colName: entityCol.name,
+          colChanges: {
+            enumItems: entityCol.enumItems
+          }
+        });
+      }
+      if (!entityCol.enumItems) {
+        colDiffs.push({
+          actionType: "DELETE",
+          colName: bdCol.name,
+          colChanges: {
+            enumItems: []
+          }
+        });
+      } else if (!bdCol.enumItems) {
+        colDiffs.push({
+          actionType: "CREATE",
+          colName: entityCol.name,
+          colChanges: {
+            enumItems: entityCol.enumItems
+          }
+        });
+      }
+    }
+  }
+}
+
+// ../../node_modules/balanc
+class Migrator2 {
+  config;
+  orm;
+  entities = new EntityStorage;
+  constructor() {
+    this.orm = Orm2.getInstance();
+    if (this.orm === undefined)
+      this.orm = new Orm2(new LoggerService(new InjectorService));
+    this.entities = EntityStorage.getInstance();
+    if (this.entities === undefined)
+      this.entities = new EntityStorage;
+  }
+  async initConfigFile(basePath = process.cwd()) {
+    const paths = await globby2(["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 paths2 = await globby2(this.config.entities, { absolute: true, cwd: basePath });
+      for (const path5 of paths2) {
+        await import(path5);
+      }
+    }
+    const serv = new OrmService2(this.orm, this.entities);
+    await serv.onInit(this.config);
+  }
+  async initMigration() {
+    const snapshotBd = await this.snapshotBd();
+    const snapshotEntities = await this.snapshotEntities();
+    const calculator = new DiffCalculator2(this.entities);
+    return calculator.diff(snapshotBd, snapshotEntities);
+  }
+  async snapshotBd() {
+    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;
+  }
+  async snapshotEntities() {
+    const snapshot = [];
+    for (let [_, values] of this.entities.entries()) {
+      snapshot.push(await this.entities.snapshot(values));
+    }
+    return snapshot;
+  }
+  async createMigration(forceName = null) {
+    const diff = await this.initMigration();
+    const migrationDirectory = path4.join(process.cwd(), this.config.migrationPath ?? "database/migrations");
+    const migrationFileName = (forceName ?? `migration_${new Date().toISOString().replace(/[^\d]/g, "")}`) + `.sql`;
+    const migrationFilePath = path4.join(migrationDirectory, migrationFileName);
+    if (!fs6.existsSync(migrationDirectory)) {
+      fs6.mkdirSync(migrationDirectory, { recursive: true });
+    }
+    let sqlInstructions = [];
+    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;
+      }
+      const colChangesMap = new Map;
+      tableDiff.colDiffs.reverse().forEach((colDiff) => {
+        const colName = colDiff.colName;
+        if (!colChangesMap.has(colName)) {
+          colChangesMap.set(colName, []);
+        }
+        colChangesMap.get(colName)?.push(colDiff);
+      });
+      colChangesMap.forEach((colDiffs, colName) => {
+        const colDiffInstructions = [];
+        colDiffs.forEach((colDiff) => {
+          switch (colDiff.actionType) {
+            case "CREATE":
+              this.orm.driverInstance.getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions);
+              break;
+            case "DELETE":
+              if (colDiff.colChanges?.enumItems && colDiff.colChanges?.enumItems.length === 0) {
+                colDiffInstructions.push(this.orm.driverInstance.getDropTypeEnumInstruction({ name: `${schema}_${tableName}_${colName}_enum` }, schema, tableName));
+                return;
+              }
+              this.orm.driverInstance.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 (colDiffInstructions.find((instruction) => instruction.includes(index.name))) {
+                    return;
+                  }
+                  if (this.alreadyConstraint(sqlInstructions, index.name)) {
+                    return;
+                  }
+                  if (index.properties) {
+                    colDiffInstructions.push(this.orm.driverInstance.getCreateIndex(index, schema, tableName));
+                  } else {
+                    colDiffInstructions.push(this.orm.driverInstance.getDropIndex(index, schema, tableName));
+                  }
+                });
+              }
+              break;
+          }
+        });
+        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 {
+      fs6.writeFileSync(migrationFilePath, migrationContent);
+      console.log(`Migration file created: ${migrationFilePath}`);
+    }
+  }
+  async migrate() {
+    const migrationTable = "cheetah_migrations";
+    const migrationDirectory = path4.join(process.cwd(), this.config.migrationPath ?? "database/migrations");
+    const migrationFiles = fs6.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);`);
+    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 = path4.join(migrationDirectory, migrationFile);
+      const migrationContent = fs6.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}`);
+    }
+  }
+  applyColumnChanges(colDiff, sqlInstructions, schema, tableName, colName) {
+    if (colDiff.colType) {
+      sqlInstructions.push(this.orm.driverInstance.getAlterTableType(schema, tableName, colName, colDiff));
+    }
+    if (colDiff.colChanges?.enumItems) {
+      sqlInstructions.push(this.orm.driverInstance.getAlterTableEnumInstruction(schema, tableName, colName, colDiff));
+    }
+    if (colDiff.colChanges) {
+      if (colDiff.colChanges.default !== undefined) {
+        sqlInstructions.push(this.orm.driverInstance.getAlterTableDefaultInstruction(schema, tableName, colName, colDiff));
+      }
+      if (colDiff.colChanges.primary !== undefined) {
+        if (colDiff.colChanges.primary) {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTablePrimaryKeyInstruction(schema, tableName, colName, colDiff));
+        } else {
+          sqlInstructions.push(this.orm.driverInstance.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.getAddUniqueConstraint(schema, tableName, colName));
+        } else {
+        }
+      }
+      if (colDiff.colChanges.nullable !== undefined) {
+        if (colDiff.colChanges.nullable) {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTableDropNullInstruction(schema, tableName, colName, colDiff));
+        } else {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTableDropNotNullInstruction(schema, tableName, colName, colDiff));
+        }
+      }
+      if (colDiff.colChanges.foreignKeys !== undefined) {
+        if (colDiff.colChanges.foreignKeys.length === 0) {
+          sqlInstructions.push(this.orm.driverInstance.getDropConstraint({ name: `${tableName}_${colName}_fk` }, schema, tableName));
+        }
+        colDiff.colChanges.foreignKeys.forEach((fk) => {
+          sqlInstructions.push(this.orm.driverInstance.getAlterTableFkInstruction(schema, tableName, colDiff, fk));
+        });
+      }
+    }
+  }
+  alreadyConstraint(sqlInstructions, s) {
+    return sqlInstructions.some((sql) => sql.includes(`"${s}"`));
+  }
+}
 export {
   getDefaultLength,
   ValueObject,
@@ -225252,6 +227447,7 @@ export {
   OrmService,
   Orm,
   OneToMany,
+  Migrator2 as Migrator,
   ManyToOne,
   Index,
   Entity,
@@ -225264,4 +227460,4 @@ export {
   AfterCreate
 };
 
-//# debugId=5625424C33EE30A864756e2164756e21
+//# debugId=618FC71B2274874064756e2164756e21