@carno.js/orm 0.2.3

package/dist/SqlBuilder.js

@@ -0,0 +1,618 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlBuilder = void 0;
+const entities_1 = require("./domain/entities");
+const orm_1 = require("./orm");
+const value_processor_1 = require("./utils/value-processor");
+const sql_condition_builder_1 = require("./query/sql-condition-builder");
+const sql_subquery_builder_1 = require("./query/sql-subquery-builder");
+const model_transformer_1 = require("./query/model-transformer");
+const sql_column_manager_1 = require("./query/sql-column-manager");
+const sql_join_manager_1 = require("./query/sql-join-manager");
+class SqlBuilder {
+    constructor(model) {
+        this.statements = {};
+        this.aliases = new Set();
+        this.updatedColumns = [];
+        this.originalColumns = [];
+        const orm = orm_1.Orm.getInstance();
+        this.driver = orm.driverInstance;
+        this.logger = orm.logger;
+        this.entityStorage = entities_1.EntityStorage.getInstance();
+        this.initializeCacheManager();
+        this.getEntity(model);
+        this.statements.hooks = this.entity.hooks;
+        this.modelTransformer = new model_transformer_1.ModelTransformer(this.entityStorage);
+        this.columnManager = new sql_column_manager_1.SqlColumnManager(this.entityStorage, this.statements, this.entity);
+        const applyJoinWrapper = (relationship, value, alias) => {
+            return this.joinManager.applyJoin(relationship, value, alias);
+        };
+        this.conditionBuilder = new sql_condition_builder_1.SqlConditionBuilder(this.entityStorage, applyJoinWrapper, this.statements);
+        const subqueryBuilder = new sql_subquery_builder_1.SqlSubqueryBuilder(this.entityStorage, () => this.conditionBuilder);
+        this.conditionBuilder.setSubqueryBuilder(subqueryBuilder);
+        this.joinManager = new sql_join_manager_1.SqlJoinManager(this.entityStorage, this.statements, this.entity, this.model, this.driver, this.logger, this.conditionBuilder, this.columnManager, this.modelTransformer, () => this.originalColumns, this.getAlias.bind(this));
+    }
+    initializeCacheManager() {
+        try {
+            const orm = orm_1.Orm.getInstance();
+            this.cacheManager = orm.queryCacheManager;
+        }
+        catch (error) {
+            this.cacheManager = undefined;
+        }
+    }
+    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();
+        const processedValues = value_processor_1.ValueProcessor.processForInsert(values, this.entity);
+        this.statements.statement = 'insert';
+        this.statements.instance = value_processor_1.ValueProcessor.createInstance(processedValues, this.model, 'insert');
+        this.statements.alias = this.getAlias(tableName);
+        this.statements.table = `"${schema}"."${tableName}"`;
+        this.statements.values = this.withUpdatedValues(this.withDefaultValues(processedValues, this.entity), this.entity);
+        this.reflectToValues();
+        return this;
+    }
+    update(values) {
+        const { tableName, schema } = this.getTableName();
+        const processedValues = value_processor_1.ValueProcessor.processForUpdate(values, this.entity);
+        this.statements.statement = 'update';
+        this.statements.alias = this.getAlias(tableName);
+        this.statements.table = `${schema}.${tableName}`;
+        this.statements.values = this.withUpdatedValues(processedValues, this.entity);
+        this.statements.instance = value_processor_1.ValueProcessor.createInstance(processedValues, this.model, 'update');
+        return this;
+    }
+    delete() {
+        const { tableName, schema } = this.getTableName();
+        this.statements.statement = 'delete';
+        this.statements.alias = this.getAlias(tableName);
+        this.statements.table = `${schema}.${tableName}`;
+        return this;
+    }
+    where(where) {
+        if (!where || Object.keys(where).length === 0) {
+            return this;
+        }
+        const newWhere = {};
+        for (const key in where) {
+            if (where[key] instanceof Object) {
+                newWhere[key] = where[key];
+                continue;
+            }
+            newWhere[value_processor_1.ValueProcessor.getColumnName(key, this.entity)] = where[key];
+        }
+        where = newWhere;
+        this.statements.where = this.conditionBuilder.build(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;
+    }
+    cache(cache) {
+        this.statements.cache = cache;
+        return this;
+    }
+    load(load) {
+        load?.forEach(relationshipPath => {
+            this.joinManager.addJoinForRelationshipPath(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;
+    }
+    count() {
+        const { tableName, schema } = this.getTableName();
+        this.statements.statement = 'count';
+        this.statements.alias = this.getAlias(tableName);
+        this.statements.table = `"${schema}"."${tableName}"`;
+        return this;
+    }
+    getPrimaryKeyColumnName(entity) {
+        // Lógica para obter o nome da coluna de chave primária da entidade
+        // Aqui você pode substituir por sua própria lógica, dependendo da estrutura do seu projeto
+        // Por exemplo, se a chave primária for sempre 'id', você pode retornar 'id'.
+        // Se a lógica for mais complexa, você pode adicionar um método na classe Options para obter a chave primária.
+        return 'id';
+    }
+    shouldUseCache() {
+        if (this.statements.statement !== 'select') {
+            return false;
+        }
+        if (this.statements.cache instanceof Date) {
+            return this.statements.cache.getTime() > Date.now();
+        }
+        return this.statements.cache !== undefined;
+    }
+    getCacheTtl() {
+        if (this.statements.cache === true) {
+            return undefined;
+        }
+        if (this.statements.cache instanceof Date) {
+            const diff = this.statements.cache.getTime() - Date.now();
+            return diff > 0 ? diff : 0;
+        }
+        return this.statements.cache;
+    }
+    async getCachedResult() {
+        if (!this.cacheManager) {
+            return undefined;
+        }
+        return this.cacheManager.get(this.statements);
+    }
+    async setCachedResult(result) {
+        if (!this.cacheManager) {
+            return;
+        }
+        const ttl = this.getCacheTtl();
+        if (ttl === 0) {
+            return;
+        }
+        await this.cacheManager.set(this.statements, result, ttl);
+    }
+    async execute() {
+        this.prepareColumns();
+        this.statements.join = this.statements.join?.reverse();
+        if (this.shouldUseCache()) {
+            const cached = await this.getCachedResult();
+            if (cached) {
+                return cached;
+            }
+        }
+        this.beforeHooks();
+        const result = await this.driver.executeStatement(this.statements);
+        this.logExecution(result);
+        if (this.shouldUseCache()) {
+            await this.setCachedResult(result);
+        }
+        return result;
+    }
+    isWriteOperation() {
+        const writeOps = ['insert', 'update', 'delete'];
+        return writeOps.includes(this.statements.statement || '');
+    }
+    async invalidateCache() {
+        if (!this.cacheManager) {
+            return;
+        }
+        await this.cacheManager.invalidate(this.statements);
+    }
+    prepareColumns() {
+        if (!this.statements.columns) {
+            this.statements.columns = this.columnManager.generateColumns(this.model, this.updatedColumns);
+            return;
+        }
+        this.statements.columns = [
+            ...this.columnManager.processUserColumns(this.statements.columns),
+            ...this.updatedColumns
+        ];
+    }
+    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() {
+        const hasOneToManyJoinedJoin = this.hasOneToManyJoinedJoin();
+        if (!hasOneToManyJoinedJoin) {
+            this.statements.limit = 1;
+        }
+        const result = await this.execute();
+        if (result.query.rows.length === 0) {
+            return undefined;
+        }
+        if (hasOneToManyJoinedJoin) {
+            return this.processOneToManyJoinedResult(result.query.rows);
+        }
+        const entities = result.query.rows[0];
+        const model = await this.modelTransformer.transform(this.model, this.statements, entities);
+        this.afterHooks(model);
+        await this.joinManager.handleSelectJoin(entities, model);
+        return model;
+    }
+    async executeAndReturnFirstOrFail() {
+        const hasOneToManyJoinedJoin = this.hasOneToManyJoinedJoin();
+        if (!hasOneToManyJoinedJoin) {
+            this.statements.limit = 1;
+        }
+        const result = await this.execute();
+        if (result.query.rows.length === 0) {
+            throw new Error('Result not found');
+        }
+        if (hasOneToManyJoinedJoin) {
+            const model = await this.processOneToManyJoinedResult(result.query.rows);
+            if (!model) {
+                throw new Error('Result not found');
+            }
+            return model;
+        }
+        const entities = result.query.rows[0];
+        const model = await this.modelTransformer.transform(this.model, this.statements, entities);
+        this.afterHooks(model);
+        await this.joinManager.handleSelectJoin(entities, model);
+        return model;
+    }
+    async executeAndReturnAll() {
+        const result = await this.execute();
+        if (result.query.rows.length === 0) {
+            return [];
+        }
+        const rows = result.query.rows;
+        const hasOneToManyJoinedJoin = this.hasOneToManyJoinedJoin();
+        if (hasOneToManyJoinedJoin) {
+            return this.processAllOneToManyJoinedResults(rows);
+        }
+        const results = [];
+        for (const row of rows) {
+            const models = this.modelTransformer.transform(this.model, this.statements, row);
+            this.afterHooks(models);
+            await this.joinManager.handleSelectJoin(row, models);
+            results.push(models);
+        }
+        return results;
+    }
+    hasOneToManyJoinedJoin() {
+        if (!this.statements.join || this.statements.join.length === 0) {
+            return false;
+        }
+        if (this.statements.strategy !== 'joined') {
+            return false;
+        }
+        return this.statements.join.some(join => {
+            const originEntity = this.getOriginEntityForJoin(join);
+            if (!originEntity) {
+                return false;
+            }
+            const relationship = originEntity.relations.find(rel => rel.propertyKey === join.joinProperty);
+            return relationship?.relation === 'one-to-many';
+        });
+    }
+    getOriginEntityForJoin(join) {
+        const rootAlias = this.statements.alias;
+        if (join.originAlias === rootAlias) {
+            return this.entity;
+        }
+        const parentJoin = this.statements.join.find(j => j.joinAlias === join.originAlias);
+        if (parentJoin && parentJoin.joinEntity) {
+            return this.entityStorage.get(parentJoin.joinEntity);
+        }
+        return null;
+    }
+    findNestedModel(model, targetAlias) {
+        if (!this.statements.join) {
+            return null;
+        }
+        for (const join of this.statements.join) {
+            if (join.joinAlias === targetAlias) {
+                const parentModel = join.originAlias === this.statements.alias
+                    ? model
+                    : this.findNestedModel(model, join.originAlias);
+                return parentModel?.[join.joinProperty];
+            }
+        }
+        return null;
+    }
+    async processOneToManyJoinedResult(rows) {
+        const primaryKey = this.getPrimaryKeyName();
+        const alias = this.statements.alias;
+        const primaryKeyColumn = `${alias}_${primaryKey}`;
+        const firstRowPrimaryKeyValue = rows[0][primaryKeyColumn];
+        const relatedRows = rows.filter(row => row[primaryKeyColumn] === firstRowPrimaryKeyValue);
+        const model = this.modelTransformer.transform(this.model, this.statements, relatedRows[0]);
+        this.afterHooks(model);
+        this.attachOneToManyRelations(model, relatedRows);
+        return model;
+    }
+    async processAllOneToManyJoinedResults(rows) {
+        const primaryKey = this.getPrimaryKeyName();
+        const alias = this.statements.alias;
+        const primaryKeyColumn = `${alias}_${primaryKey}`;
+        const groupedRows = new Map();
+        for (const row of rows) {
+            const pkValue = row[primaryKeyColumn];
+            if (!groupedRows.has(pkValue)) {
+                groupedRows.set(pkValue, []);
+            }
+            groupedRows.get(pkValue).push(row);
+        }
+        const results = [];
+        for (const [, relatedRows] of groupedRows) {
+            const model = this.modelTransformer.transform(this.model, this.statements, relatedRows[0]);
+            this.afterHooks(model);
+            this.attachOneToManyRelations(model, relatedRows);
+            results.push(model);
+        }
+        return results;
+    }
+    attachOneToManyRelations(model, rows) {
+        if (!this.statements.join) {
+            return;
+        }
+        for (const join of this.statements.join) {
+            const originEntity = this.getOriginEntityForJoin(join);
+            if (!originEntity) {
+                continue;
+            }
+            const relationship = originEntity.relations.find(rel => rel.propertyKey === join.joinProperty);
+            if (relationship?.relation === 'one-to-many') {
+                const joinedModels = rows.map(row => this.modelTransformer.transform(join.joinEntity, { alias: join.joinAlias }, row));
+                const uniqueModels = this.removeDuplicatesByPrimaryKey(joinedModels, join.joinEntity);
+                const targetModel = join.originAlias === this.statements.alias
+                    ? model
+                    : this.findNestedModel(model, join.originAlias);
+                if (targetModel) {
+                    targetModel[join.joinProperty] = uniqueModels;
+                }
+            }
+        }
+    }
+    removeDuplicatesByPrimaryKey(models, entityClass) {
+        const entity = this.entityStorage.get(entityClass);
+        if (!entity) {
+            return models;
+        }
+        const primaryKey = this.getPrimaryKeyNameForEntity(entity);
+        const seen = new Set();
+        const unique = [];
+        for (const model of models) {
+            const id = model[primaryKey];
+            if (id && !seen.has(id)) {
+                seen.add(id);
+                unique.push(model);
+            }
+        }
+        return unique;
+    }
+    getPrimaryKeyName() {
+        return this.getPrimaryKeyNameForEntity(this.entity);
+    }
+    getPrimaryKeyNameForEntity(entity) {
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+    async executeCount() {
+        const result = await this.execute();
+        if (result.query.rows.length === 0) {
+            return 0;
+        }
+        return parseInt(result.query.rows[0].count);
+    }
+    logExecution(result) {
+        this.logger.debug(`SQL: ${result.sql} [${Date.now() - result.startTime}ms]`);
+    }
+    async inTransaction(callback) {
+        return await this.driver.transaction(async (tx) => {
+            // @ts-ignore
+            return await callback(this);
+        });
+    }
+    objectToStringMap(obj, parentKey = '') {
+        return Object.keys(obj)
+            .filter(key => obj.hasOwnProperty(key))
+            .flatMap(key => this.mapObjectKey(obj, key, parentKey));
+    }
+    mapObjectKey(obj, key, parentKey) {
+        const fullKey = parentKey ? `${parentKey}.${key}` : key;
+        if (this.isNestedObject(obj[key])) {
+            return this.objectToStringMap(obj[key], fullKey);
+        }
+        if (parentKey) {
+            const columnPath = this.buildColumnPath(fullKey);
+            return [`${this.columnManager.discoverAlias(columnPath, true)} ${obj[key]}`];
+        }
+        const columnName = value_processor_1.ValueProcessor.getColumnName(key, this.entity);
+        return [`${this.columnManager.discoverAlias(columnName, true)} ${obj[key]}`];
+    }
+    isNestedObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    buildColumnPath(path) {
+        const segments = this.splitPath(path);
+        const entity = this.resolvePathEntity(segments.parents);
+        const column = this.resolveColumn(segments.column, entity);
+        return this.joinSegments(segments.parents, column);
+    }
+    splitPath(path) {
+        const parts = path.split('.');
+        const column = parts.pop() ?? path;
+        return { parents: parts, column };
+    }
+    resolvePathEntity(parents) {
+        let current = this.entity;
+        for (const relation of parents) {
+            current = this.nextEntity(current, relation);
+        }
+        return current;
+    }
+    nextEntity(entity, relation) {
+        const relations = entity.relations ?? [];
+        const meta = relations.find(rel => rel.propertyKey === relation);
+        if (!meta) {
+            throw new Error(`Relationship "${relation}" not found for ORDER BY path`);
+        }
+        const next = this.entityStorage.get(meta.entity());
+        if (!next) {
+            throw new Error(`Entity metadata not found for relation "${relation}"`);
+        }
+        return next;
+    }
+    resolveColumn(column, entity) {
+        return value_processor_1.ValueProcessor.getColumnName(column, entity);
+    }
+    joinSegments(parents, column) {
+        if (parents.length === 0) {
+            return column;
+        }
+        return `${parents.join('.')}.${column}`;
+    }
+    getTableName() {
+        const tableName = this.entity.tableName || this.model.name.toLowerCase();
+        const schema = this.entity.schema || 'public';
+        return { tableName, schema };
+    }
+    t(value) {
+        return (typeof value === 'string') ? `'${value}'` : value;
+    }
+    // private conditionLogicalOperatorToSql<T extends typeof BaseEntity>(conditions: Condition<T>[], operator: 'AND' | 'OR'): string {
+    //   const sqlParts = conditions.map(cond => this.conditionToSql(cond));
+    //   return this.addLogicalOperatorToSql(sqlParts, operator);
+    // }
+    getEntity(model) {
+        const entity = this.entityStorage.get(model);
+        this.model = model;
+        if (!entity) {
+            throw new Error('Entity not found');
+        }
+        this.entity = entity;
+    }
+    /**
+     * Retrieves an alias for a given table name.
+     *
+     * @param {string} tableName - The name of the table.
+     * @private
+     * @returns {string} - The alias for the table name.
+     */
+    getAlias(tableName) {
+        const baseAlias = tableName.split('').shift() || '';
+        const uniqueAlias = this.generateUniqueAlias(baseAlias);
+        this.aliases.add(uniqueAlias);
+        return uniqueAlias;
+    }
+    generateUniqueAlias(baseAlias) {
+        let counter = 1;
+        let candidate = `${baseAlias}${counter}`;
+        while (this.aliases.has(candidate)) {
+            counter++;
+            candidate = `${baseAlias}${counter}`;
+        }
+        return candidate;
+    }
+    withDefaultValues(values, entityOptions) {
+        this.applyDefaultProperties(values, entityOptions);
+        this.applyOnInsertProperties(values, entityOptions);
+        return values;
+    }
+    applyDefaultProperties(values, entityOptions) {
+        const defaultProperties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.default);
+        for (const [key, property] of defaultProperties) {
+            this.setDefaultValue(values, key, property);
+        }
+    }
+    setDefaultValue(values, key, property) {
+        const columnName = property.options.columnName;
+        if (typeof values[columnName] !== 'undefined')
+            return;
+        values[columnName] = typeof property.options.default === 'function'
+            ? property.options.default()
+            : property.options.default;
+    }
+    applyOnInsertProperties(values, entityOptions) {
+        const properties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onInsert);
+        properties.forEach(([key, property]) => this.applyOnInsert(values, key, property));
+    }
+    applyOnInsert(values, key, property) {
+        const columnName = property.options.columnName;
+        values[columnName] = property.options.onInsert();
+        this.updatedColumns.push(`${this.statements.alias}."${columnName}" as "${this.statements.alias}_${columnName}"`);
+    }
+    withUpdatedValues(values, entityOptions) {
+        const properties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
+        properties.forEach(([key, property]) => this.applyOnUpdate(values, property));
+        return values;
+    }
+    applyOnUpdate(values, property) {
+        const columnName = property.options.columnName;
+        values[columnName] = property.options.onUpdate();
+        this.updatedColumns.push(`${this.statements.alias}."${columnName}" as "${this.statements.alias}_${columnName}"`);
+    }
+    callHook(type, model) {
+        const hooks = this.statements.hooks?.filter(hook => hook.type === type) || [];
+        const instance = model || this.statements.instance;
+        hooks.forEach(hook => this.executeHook(hook, instance, !model));
+    }
+    executeHook(hook, instance, shouldReflect) {
+        instance[hook.propertyName]();
+        if (shouldReflect)
+            this.reflectToValues();
+    }
+    reflectToValues() {
+        for (const key in this.statements.instance) {
+            if (this.shouldSkipKey(key))
+                continue;
+            this.reflectKey(key);
+        }
+    }
+    shouldSkipKey(key) {
+        return key.startsWith('$') || key.startsWith('_');
+    }
+    reflectKey(key) {
+        if (this.entity.properties[key]) {
+            this.reflectProperty(key);
+            return;
+        }
+        this.reflectRelation(key);
+    }
+    reflectProperty(key) {
+        const columnName = this.entity.properties[key].options.columnName;
+        this.statements.values[columnName] = this.statements.instance[key];
+    }
+    reflectRelation(key) {
+        const rel = this.entity.relations.find(rel => rel.propertyKey === key);
+        if (rel) {
+            this.statements.values[rel.columnName] = this.statements.instance[key];
+        }
+    }
+}
+exports.SqlBuilder = SqlBuilder;

package/dist/cache/cache-key-generator.d.ts

@@ -0,0 +1,13 @@
+import { Statement } from '../driver/driver.interface';
+export declare class CacheKeyGenerator {
+    generate(statement: Statement<any>): string;
+    private buildKeyParts;
+    private addTableName;
+    private addColumns;
+    private addWhere;
+    private addOrderBy;
+    private addLimits;
+    private addJoins;
+    private combineKeyParts;
+    private hashKey;
+}

package/dist/cache/cache-key-generator.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheKeyGenerator = void 0;
+const crypto_1 = require("crypto");
+class CacheKeyGenerator {
+    generate(statement) {
+        const parts = this.buildKeyParts(statement);
+        const combined = this.combineKeyParts(parts);
+        return this.hashKey(combined);
+    }
+    buildKeyParts(statement) {
+        const parts = [];
+        this.addTableName(parts, statement);
+        this.addColumns(parts, statement);
+        this.addWhere(parts, statement);
+        this.addOrderBy(parts, statement);
+        this.addLimits(parts, statement);
+        this.addJoins(parts, statement);
+        return parts;
+    }
+    addTableName(parts, statement) {
+        if (statement.table) {
+            parts.push(`table:${statement.table}`);
+        }
+    }
+    addColumns(parts, statement) {
+        if (statement.columns?.length) {
+            parts.push(`cols:${statement.columns.join(',')}`);
+        }
+    }
+    addWhere(parts, statement) {
+        if (statement.where) {
+            parts.push(`where:${statement.where}`);
+        }
+    }
+    addOrderBy(parts, statement) {
+        if (statement.orderBy?.length) {
+            parts.push(`order:${statement.orderBy.join(',')}`);
+        }
+    }
+    addLimits(parts, statement) {
+        if (statement.limit !== undefined) {
+            parts.push(`limit:${statement.limit}`);
+        }
+        if (statement.offset !== undefined) {
+            parts.push(`offset:${statement.offset}`);
+        }
+    }
+    addJoins(parts, statement) {
+        if (statement.join?.length) {
+            const joinStr = statement.join
+                .map((j) => `${j.joinTable}:${j.type}:${j.on}`)
+                .join('|');
+            parts.push(`join:${joinStr}`);
+        }
+    }
+    combineKeyParts(parts) {
+        return parts.join('::');
+    }
+    hashKey(key) {
+        return (0, crypto_1.createHash)('md5')
+            .update(key)
+            .digest('hex');
+    }
+}
+exports.CacheKeyGenerator = CacheKeyGenerator;