@carno.js/orm 0.2.3

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identityMapContext = exports.IdentityMapMiddleware = exports.transactionContext = exports.EntityStorage = void 0;
+__exportStar(require("./decorators/entity.decorator"), exports);
+__exportStar(require("./decorators/property.decorator"), exports);
+__exportStar(require("./decorators/primary-key.decorator"), exports);
+__exportStar(require("./decorators/one-many.decorator"), exports);
+__exportStar(require("./decorators/index.decorator"), exports);
+__exportStar(require("./decorators/unique.decorator"), exports);
+__exportStar(require("./decorators/event-hook.decorator"), exports);
+__exportStar(require("./decorators/enum.decorator"), exports);
+__exportStar(require("./decorators/computed.decorator"), exports);
+__exportStar(require("./orm"), exports);
+__exportStar(require("./orm.service"), exports);
+__exportStar(require("./domain/base-entity"), exports);
+__exportStar(require("./domain/reference"), exports);
+var entities_1 = require("./domain/entities");
+Object.defineProperty(exports, "EntityStorage", { enumerable: true, get: function () { return entities_1.EntityStorage; } });
+__exportStar(require("./driver/bun-pg.driver"), exports);
+__exportStar(require("./driver/bun-mysql.driver"), exports);
+__exportStar(require("./driver/bun-driver.base"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./driver/driver.interface"), exports);
+__exportStar(require("./entry"), exports);
+__exportStar(require("./common/value-object"), exports);
+__exportStar(require("./common/email.vo"), exports);
+__exportStar(require("./common/uuid"), exports);
+__exportStar(require("./repository/Repository"), exports);
+var transaction_context_1 = require("./transaction/transaction-context");
+Object.defineProperty(exports, "transactionContext", { enumerable: true, get: function () { return transaction_context_1.transactionContext; } });
+var identity_map_middleware_1 = require("./middleware/identity-map.middleware");
+Object.defineProperty(exports, "IdentityMapMiddleware", { enumerable: true, get: function () { return identity_map_middleware_1.IdentityMapMiddleware; } });
+var identity_map_1 = require("./identity-map");
+Object.defineProperty(exports, "identityMapContext", { enumerable: true, get: function () { return identity_map_1.identityMapContext; } });

package/dist/middleware/identity-map.middleware.d.ts

@@ -0,0 +1,4 @@
+import { CarnoMiddleware, Context } from '@carno.js/core';
+export declare class IdentityMapMiddleware implements CarnoMiddleware {
+    handle(ctx: Context, next: () => void): Promise<void>;
+}

package/dist/middleware/identity-map.middleware.js

@@ -0,0 +1,22 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, 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(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityMapMiddleware = void 0;
+const core_1 = require("@carno.js/core");
+const identity_map_1 = require("../identity-map");
+let IdentityMapMiddleware = class IdentityMapMiddleware {
+    async handle(ctx, next) {
+        await identity_map_1.identityMapContext.run(async () => {
+            await next();
+        });
+    }
+};
+exports.IdentityMapMiddleware = IdentityMapMiddleware;
+exports.IdentityMapMiddleware = IdentityMapMiddleware = __decorate([
+    (0, core_1.Injectable)()
+], IdentityMapMiddleware);

package/dist/orm-session-context.d.ts

@@ -0,0 +1,16 @@
+import type { Orm } from './orm';
+import type { EntityStorage } from './domain/entities';
+type OrmSession = {
+    orm: Orm<any>;
+    storage: EntityStorage;
+};
+declare class OrmSessionContext {
+    private storage;
+    constructor();
+    run<T>(session: OrmSession, routine: () => Promise<T>): Promise<T>;
+    getOrm(): Orm<any> | undefined;
+    getStorage(): EntityStorage | undefined;
+    hasContext(): boolean;
+}
+export declare const ormSessionContext: OrmSessionContext;
+export type { OrmSession };

package/dist/orm-session-context.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ormSessionContext = void 0;
+const async_hooks_1 = require("async_hooks");
+class OrmSessionContext {
+    constructor() {
+        this.storage = new async_hooks_1.AsyncLocalStorage();
+    }
+    run(session, routine) {
+        return this.storage.run(session, routine);
+    }
+    getOrm() {
+        return this.storage.getStore()?.orm;
+    }
+    getStorage() {
+        return this.storage.getStore()?.storage;
+    }
+    hasContext() {
+        return this.storage.getStore() !== undefined;
+    }
+}
+exports.ormSessionContext = new OrmSessionContext();

package/dist/orm.d.ts

@@ -0,0 +1,20 @@
+import { ConnectionSettings, DriverInterface } from './driver/driver.interface';
+import { LoggerService, CacheService } from '@carno.js/core';
+import { SqlBuilder } from './SqlBuilder';
+import { QueryCacheManager } from './cache/query-cache-manager';
+export declare class Orm<T extends DriverInterface = DriverInterface> {
+    logger: LoggerService;
+    cacheService?: CacheService;
+    driverInstance: T;
+    static instance: Orm<any>;
+    connection: ConnectionSettings<T>;
+    queryCacheManager?: QueryCacheManager;
+    constructor(logger: LoggerService, cacheService?: CacheService);
+    private initializeQueryCacheManager;
+    static getInstance(): Orm<any>;
+    setConnection(connection: ConnectionSettings<T>): void;
+    createQueryBuilder<Model>(model: new () => Model): SqlBuilder<Model>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction<ResultType>(operation: (tx: unknown) => Promise<ResultType>): Promise<ResultType>;
+}

package/dist/orm.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, 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(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var Orm_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orm = void 0;
+const core_1 = require("@carno.js/core");
+const SqlBuilder_1 = require("./SqlBuilder");
+const query_cache_manager_1 = require("./cache/query-cache-manager");
+const transaction_context_1 = require("./transaction/transaction-context");
+const orm_session_context_1 = require("./orm-session-context");
+let Orm = Orm_1 = class Orm {
+    constructor(logger, cacheService) {
+        this.logger = logger;
+        this.cacheService = cacheService;
+        Orm_1.instance = this;
+        this.initializeQueryCacheManager();
+    }
+    initializeQueryCacheManager() {
+        if (this.cacheService) {
+            this.queryCacheManager = new query_cache_manager_1.QueryCacheManager(this.cacheService);
+        }
+    }
+    static getInstance() {
+        const scoped = orm_session_context_1.ormSessionContext.getOrm();
+        if (scoped) {
+            return scoped;
+        }
+        return Orm_1.instance;
+    }
+    setConnection(connection) {
+        this.connection = connection;
+        // @ts-ignore
+        this.driverInstance = new this.connection.driver(connection);
+    }
+    createQueryBuilder(model) {
+        return new SqlBuilder_1.SqlBuilder(model);
+    }
+    connect() {
+        return this.driverInstance.connect();
+    }
+    disconnect() {
+        return this.driverInstance.disconnect();
+    }
+    async transaction(operation) {
+        if (!this.driverInstance) {
+            throw new Error('Driver instance not initialized');
+        }
+        if (transaction_context_1.transactionContext.hasContext()) {
+            return operation(transaction_context_1.transactionContext.getContext());
+        }
+        return this.driverInstance.transaction(async (tx) => {
+            return transaction_context_1.transactionContext.run(tx, () => operation(tx));
+        });
+    }
+};
+exports.Orm = Orm;
+exports.Orm = Orm = Orm_1 = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [core_1.LoggerService,
+        core_1.CacheService])
+], Orm);

package/dist/orm.service.d.ts

@@ -0,0 +1,13 @@
+import { EntityStorage } from './domain/entities';
+import { Orm } from './orm';
+export declare class OrmService {
+    private orm;
+    private storage;
+    private allEntities;
+    private project;
+    constructor(orm: Orm, storage: EntityStorage, entityFile?: string);
+    private discoverRelationshipTypes;
+    private discoverEnumTypes;
+    onInit(customConfig?: any): Promise<void>;
+    private getSourceFilePaths;
+}

package/dist/orm.service.js

@@ -0,0 +1,361 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, 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(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrmService = void 0;
+const core_1 = require("@carno.js/core");
+const entities_1 = require("./domain/entities");
+const constants_1 = require("./constants");
+const ts_morph_1 = require("ts-morph");
+const orm_1 = require("./orm");
+const globby = __importStar(require("globby"));
+const path_1 = __importDefault(require("path"));
+let OrmService = class OrmService {
+    constructor(orm, storage, entityFile) {
+        this.orm = orm;
+        this.storage = storage;
+        this.allEntities = new Map();
+        this.project = new ts_morph_1.Project({ skipLoadingLibFiles: true });
+        const files = this.project.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(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 ts_morph_1.SyntaxKind.StringLiteral:
+                                    defaults[propertyName] = initializer.getText();
+                                    break;
+                                case ts_morph_1.SyntaxKind.NumericLiteral:
+                                    defaults[propertyName] = parseFloat(initializer.getText());
+                                    break;
+                                case ts_morph_1.SyntaxKind.NewExpression:
+                                case ts_morph_1.SyntaxKind.CallExpression:
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                        this.allEntities.set(classDeclaration.getName(), { nullables, defaults });
+                    });
+                }
+            });
+        });
+    }
+    discoverRelationshipTypes(files) {
+        const entityNameToClass = new Map();
+        const processedClasses = new Set();
+        const entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect) || [];
+        for (const entity of entities) {
+            entityNameToClass.set(entity.target.name, entity.target);
+        }
+        files.forEach(file => {
+            file.getClasses().forEach(classDeclaration => {
+                if (!classDeclaration.getDecorator('Entity'))
+                    return;
+                const className = classDeclaration.getName();
+                const targetClass = entityNameToClass.get(className);
+                if (!targetClass)
+                    return;
+                processedClasses.add(className);
+                const relationships = core_1.Metadata.get(constants_1.PROPERTIES_RELATIONS, targetClass) || [];
+                classDeclaration.getProperties().forEach(property => {
+                    const propertyName = property.getName();
+                    const relationship = relationships.find(r => r.propertyKey === propertyName);
+                    if (relationship && relationship.entity === '__AUTO_DETECT__' && relationship.relation === 'many-to-one') {
+                        const typeNode = property.getTypeNode();
+                        if (!typeNode)
+                            return;
+                        const entityTypeName = typeNode.getText().trim();
+                        if (entityTypeName) {
+                            const entityClass = entityNameToClass.get(entityTypeName);
+                            if (entityClass) {
+                                relationship.entity = () => entityClass;
+                            }
+                            else {
+                                console.warn(`Warning: Could not find entity "${entityTypeName}" for relationship ` +
+                                    `"${className}.${propertyName}". Please define it explicitly.`);
+                            }
+                        }
+                    }
+                });
+                core_1.Metadata.set(constants_1.PROPERTIES_RELATIONS, relationships, targetClass);
+            });
+        });
+        for (const entity of entities) {
+            if (processedClasses.has(entity.target.name))
+                continue;
+            const relationships = core_1.Metadata.get(constants_1.PROPERTIES_RELATIONS, entity.target) || [];
+            let updated = false;
+            for (const relationship of relationships) {
+                if (relationship.entity === '__AUTO_DETECT__' && relationship.relation === 'many-to-one') {
+                    const propertyKey = relationship.propertyKey;
+                    const capitalizedName = propertyKey.charAt(0).toUpperCase() + propertyKey.slice(1);
+                    let entityClass = entityNameToClass.get(capitalizedName);
+                    if (!entityClass) {
+                        for (const [name, cls] of entityNameToClass) {
+                            if (name.toLowerCase() === propertyKey.toLowerCase()) {
+                                entityClass = cls;
+                                break;
+                            }
+                        }
+                    }
+                    if (entityClass) {
+                        relationship.entity = () => entityClass;
+                        updated = true;
+                    }
+                    else {
+                        console.warn(`Warning: Could not auto-detect entity for "${entity.target.name}.${propertyKey}". ` +
+                            `Please define it explicitly.`);
+                    }
+                }
+            }
+            if (updated) {
+                core_1.Metadata.set(constants_1.PROPERTIES_RELATIONS, relationships, entity.target);
+            }
+        }
+    }
+    discoverEnumTypes(files, entities) {
+        const entityNameToClass = new Map();
+        for (const entity of entities) {
+            entityNameToClass.set(entity.target.name, entity.target);
+        }
+        files.forEach(file => {
+            file.getClasses().forEach(classDeclaration => {
+                if (!classDeclaration.getDecorator('Entity'))
+                    return;
+                const className = classDeclaration.getName();
+                const targetClass = entityNameToClass.get(className);
+                if (!targetClass)
+                    return;
+                const properties = core_1.Metadata.get(constants_1.PROPERTIES_METADATA, targetClass) || {};
+                classDeclaration.getProperties().forEach(property => {
+                    const propertyName = property.getName();
+                    const propertyMetadata = properties[propertyName];
+                    if (propertyMetadata?.options?.enumItems === '__AUTO_DETECT__') {
+                        const typeNode = property.getTypeNode();
+                        if (!typeNode)
+                            return;
+                        const enumTypeName = typeNode.getText().trim();
+                        const enumArrayMatch = enumTypeName.match(/^(.+)\[\]$/);
+                        const actualEnumName = enumArrayMatch ? enumArrayMatch[1] : enumTypeName;
+                        const sourceFile = file;
+                        const enumDeclaration = sourceFile.getEnum(actualEnumName);
+                        if (enumDeclaration) {
+                            const enumMembers = enumDeclaration.getMembers();
+                            const enumValues = enumMembers.map(member => {
+                                const value = member.getValue();
+                                return value !== undefined ? value : member.getName();
+                            });
+                            propertyMetadata.options.enumItems = enumValues;
+                            if (enumArrayMatch) {
+                                propertyMetadata.options.array = true;
+                            }
+                        }
+                        else {
+                            const allSourceFiles = sourceFile.getProject().getSourceFiles();
+                            let foundEnum = false;
+                            for (const sf of allSourceFiles) {
+                                const importedEnum = sf.getEnum(actualEnumName);
+                                if (importedEnum) {
+                                    const enumMembers = importedEnum.getMembers();
+                                    const enumValues = enumMembers.map(member => {
+                                        const value = member.getValue();
+                                        return value !== undefined ? value : member.getName();
+                                    });
+                                    propertyMetadata.options.enumItems = enumValues;
+                                    if (enumArrayMatch) {
+                                        propertyMetadata.options.array = true;
+                                    }
+                                    foundEnum = true;
+                                    break;
+                                }
+                            }
+                            if (!foundEnum) {
+                                console.warn(`Warning: Could not find enum "${actualEnumName}" for property ` +
+                                    `"${className}.${propertyName}". Please define it explicitly.`);
+                            }
+                        }
+                    }
+                });
+                core_1.Metadata.set(constants_1.PROPERTIES_METADATA, properties, targetClass);
+            });
+        });
+    }
+    async onInit(customConfig = {}) {
+        const hasCustomConfig = Object.keys(customConfig).length > 0;
+        let config = null;
+        let setConfig;
+        if (!hasCustomConfig) {
+            const configFile = globby.sync('carno.config.ts', { absolute: true });
+            if (configFile.length === 0) {
+                console.log('No config file found!');
+                return;
+            }
+            config = await Promise.resolve(`${configFile[0]}`).then(s => __importStar(require(s)));
+            setConfig = config.default;
+        }
+        else {
+            setConfig = customConfig;
+        }
+        this.orm.setConnection(setConfig);
+        await this.orm.connect();
+        if (config && typeof config.default.entities === 'string') {
+            const files = globby.sync([config.default.entities, '!node_modules'], { gitignore: true, absolute: true });
+            for (const file of files) {
+                await Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+            }
+        }
+        let entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect);
+        if (!entities) {
+            const entityPaths = this.getSourceFilePaths();
+            const entityFiles = globby.sync(entityPaths.filter(path => path.includes('.entity.') || path.includes('entities/')));
+            for (const file of entityFiles) {
+                try {
+                    await Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+                }
+                catch (error) {
+                    console.warn(`Failed to import entity file ${file}:`, error);
+                }
+            }
+            entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect);
+        }
+        if (!entities) {
+            console.log('No entities found!');
+            return;
+        }
+        const files = this.project.getSourceFiles();
+        this.discoverRelationshipTypes(files);
+        this.discoverEnumTypes(files, entities);
+        for (const entity of entities) {
+            const nullableDefaultEntity = this.allEntities.get(entity.target.name);
+            const propertiesFromMetadata = core_1.Metadata.get(constants_1.PROPERTIES_METADATA, entity.target);
+            const relationshipsFromMetadata = core_1.Metadata.get(constants_1.PROPERTIES_RELATIONS, entity.target) || [];
+            const hooks = core_1.Metadata.get(constants_1.EVENTS_METADATA, entity.target);
+            // Cria uma cópia profunda das propriedades para evitar mutação compartilhada
+            const properties = {};
+            if (propertiesFromMetadata) {
+                for (const [key, value] of Object.entries(propertiesFromMetadata)) {
+                    properties[key] = {
+                        type: value.type,
+                        options: { ...value.options }
+                    };
+                }
+            }
+            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];
+                }
+            }
+            const relationships = relationshipsFromMetadata.map((relation) => ({ ...relation }));
+            for (const relation of relationships) {
+                const relationKey = String(relation.propertyKey);
+                if (nullableDefaultEntity?.nullables.includes(relationKey)) {
+                    relation.nullable = true;
+                }
+            }
+            this.storage.add(entity, properties, relationships, hooks);
+        }
+    }
+    getSourceFilePaths() {
+        const projectRoot = process.cwd();
+        const patterns = [
+            '**/*.entity.ts',
+            '**/entities/**/*.ts',
+            '**/entity/**/*.ts',
+            '**/*.entity.js',
+            '**/entities/**/*.js',
+            '**/entity/**/*.js',
+            '!**/node_modules/**',
+            '!**/test/**',
+            '!**/tests/**',
+            '!**/*.spec.ts',
+            '!**/*.test.ts',
+            '!**/*.spec.js',
+            '!**/*.test.js',
+            '!**/dist/**',
+            '!**/build/**'
+        ];
+        try {
+            return globby
+                .sync(patterns, { cwd: projectRoot, gitignore: true, absolute: false })
+                .map((filePath) => path_1.default.resolve(projectRoot, filePath));
+        }
+        catch (error) {
+            console.error('Erro ao obter arquivos:', error);
+            return [];
+        }
+    }
+};
+exports.OrmService = OrmService;
+__decorate([
+    (0, core_1.OnApplicationInit)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OrmService.prototype, "onInit", null);
+exports.OrmService = OrmService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [orm_1.Orm, entities_1.EntityStorage, String])
+], OrmService);

package/dist/query/index-condition-builder.d.ts

@@ -0,0 +1,41 @@
+import { FilterQuery } from '../driver/driver.interface';
+export declare class IndexConditionBuilder<T> {
+    private columnMap;
+    private readonly OPERATORS;
+    private lastKeyNotOperator;
+    constructor(columnMap: Record<string, string>);
+    build(condition: FilterQuery<T>): string;
+    private processConditions;
+    private getEntries;
+    private processEntries;
+    private processEntry;
+    private handleScalarValue;
+    private handleObjectValue;
+    private buildLogicalOperatorCondition;
+    private buildOperatorConditions;
+    private buildOperatorCondition;
+    private buildSimpleCondition;
+    private buildInCondition;
+    private buildNotInCondition;
+    private buildLikeCondition;
+    private buildComparisonCondition;
+    private buildNestedLogicalCondition;
+    private buildNorCondition;
+    private wrapWithLogicalOperator;
+    private extractValueFromValueObject;
+    private formatValue;
+    private formatDate;
+    private isNullish;
+    private isPrimitive;
+    private formatPrimitive;
+    private formatJson;
+    private escapeString;
+    private isScalarValue;
+    private isArrayValue;
+    private isLogicalOperator;
+    private isNorOperator;
+    private extractLogicalOperator;
+    private trackLastNonOperatorKey;
+    private resolveColumnName;
+    private buildNullCondition;
+}