@carno.js/orm 0.2.3

package/dist/query/index-condition-builder.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexConditionBuilder = void 0;
+const value_object_1 = require("../common/value-object");
+const utils_1 = require("../utils");
+class IndexConditionBuilder {
+    constructor(columnMap) {
+        this.columnMap = columnMap;
+        this.OPERATORS = [
+            '$eq',
+            '$ne',
+            '$in',
+            '$nin',
+            '$like',
+            '$gt',
+            '$gte',
+            '$lt',
+            '$lte',
+            '$and',
+            '$or',
+            '$nor',
+        ];
+        this.lastKeyNotOperator = '';
+    }
+    build(condition) {
+        const sqlParts = this.processConditions(condition);
+        if (sqlParts.length === 0) {
+            return '';
+        }
+        return this.wrapWithLogicalOperator(sqlParts, 'AND');
+    }
+    processConditions(condition) {
+        const entries = this.getEntries(condition);
+        return this.processEntries(entries);
+    }
+    getEntries(condition) {
+        if (!condition || typeof condition !== 'object') {
+            return [];
+        }
+        return Object.entries(condition);
+    }
+    processEntries(entries) {
+        const sqlParts = [];
+        for (const [key, value] of entries) {
+            const extractedValue = this.extractValueFromValueObject(value);
+            const conditionSql = this.processEntry(key, extractedValue);
+            if (conditionSql) {
+                sqlParts.push(conditionSql);
+            }
+        }
+        return sqlParts;
+    }
+    processEntry(key, value) {
+        this.trackLastNonOperatorKey(key);
+        if (this.isScalarValue(value)) {
+            return this.handleScalarValue(key, value);
+        }
+        if (this.isArrayValue(key, value)) {
+            return this.buildInCondition(key, value);
+        }
+        return this.handleObjectValue(key, value);
+    }
+    handleScalarValue(key, value) {
+        if (key === '$eq') {
+            return this.buildSimpleCondition(this.lastKeyNotOperator, value, '=');
+        }
+        return this.buildSimpleCondition(key, value, '=');
+    }
+    handleObjectValue(key, value) {
+        if (this.isLogicalOperator(key)) {
+            return this.buildLogicalOperatorCondition(key, value);
+        }
+        if (this.isNorOperator(key)) {
+            return this.buildNorCondition(value);
+        }
+        return this.buildOperatorConditions(key, value);
+    }
+    buildLogicalOperatorCondition(key, value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const operator = this.extractLogicalOperator(key);
+        return this.wrapWithLogicalOperator(conditions, operator);
+    }
+    buildOperatorConditions(key, value) {
+        const parts = [];
+        for (const operator of this.OPERATORS) {
+            if (operator in value) {
+                const condition = this.buildOperatorCondition(key, operator, value[operator]);
+                parts.push(condition);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    buildOperatorCondition(key, operator, value) {
+        switch (operator) {
+            case '$eq':
+                return this.buildSimpleCondition(key, value, '=');
+            case '$ne':
+                return this.buildSimpleCondition(key, value, '!=');
+            case '$in':
+                return this.buildInCondition(key, value);
+            case '$nin':
+                return this.buildNotInCondition(key, value);
+            case '$like':
+                return this.buildLikeCondition(key, value);
+            case '$gt':
+                return this.buildComparisonCondition(key, value, '>');
+            case '$gte':
+                return this.buildComparisonCondition(key, value, '>=');
+            case '$lt':
+                return this.buildComparisonCondition(key, value, '<');
+            case '$lte':
+                return this.buildComparisonCondition(key, value, '<=');
+            case '$and':
+            case '$or':
+                return this.buildNestedLogicalCondition(operator, value);
+            case '$nor':
+                return this.buildNorCondition(value);
+            default:
+                return '';
+        }
+    }
+    buildSimpleCondition(key, value, operator) {
+        const column = this.resolveColumnName(key);
+        if (this.isNullish(value))
+            return this.buildNullCondition(column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${column} ${operator} ${formattedValue}`;
+    }
+    buildInCondition(key, values) {
+        const column = this.resolveColumnName(key);
+        const formattedValues = values.map((val) => this.formatValue(val)).join(', ');
+        return `${column} IN (${formattedValues})`;
+    }
+    buildNotInCondition(key, values) {
+        const column = this.resolveColumnName(key);
+        const formattedValues = values.map((val) => this.formatValue(val)).join(', ');
+        return `${column} NOT IN (${formattedValues})`;
+    }
+    buildLikeCondition(key, value) {
+        const column = this.resolveColumnName(key);
+        return `${column} LIKE '${value}'`;
+    }
+    buildComparisonCondition(key, value, operator) {
+        const column = this.resolveColumnName(key);
+        if (this.isNullish(value))
+            return this.buildNullCondition(column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${column} ${operator} ${formattedValue}`;
+    }
+    buildNestedLogicalCondition(operator, value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const logicalOp = this.extractLogicalOperator(operator);
+        return this.wrapWithLogicalOperator(conditions, logicalOp);
+    }
+    buildNorCondition(value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const wrapped = this.wrapWithLogicalOperator(conditions, 'OR');
+        return `NOT ${wrapped}`;
+    }
+    wrapWithLogicalOperator(conditions, operator) {
+        return `(${conditions.join(` ${operator} `)})`;
+    }
+    extractValueFromValueObject(value) {
+        if ((0, utils_1.extendsFrom)(value_object_1.ValueObject, value?.constructor?.prototype)) {
+            return value.getValue();
+        }
+        return value;
+    }
+    formatValue(value) {
+        if (value instanceof Date)
+            return this.formatDate(value);
+        if (this.isNullish(value))
+            return 'NULL';
+        if (this.isPrimitive(value))
+            return this.formatPrimitive(value);
+        return this.formatJson(value);
+    }
+    formatDate(value) {
+        return `'${value.toISOString()}'`;
+    }
+    isNullish(value) {
+        return value === null || value === undefined;
+    }
+    isPrimitive(value) {
+        return ['string', 'number', 'boolean', 'bigint'].includes(typeof value);
+    }
+    formatPrimitive(value) {
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        return `${value}`;
+    }
+    formatJson(value) {
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    escapeString(value) {
+        return value.replace(/'/g, "''");
+    }
+    isScalarValue(value) {
+        const isDate = value instanceof Date;
+        return typeof value !== 'object' || value === null || isDate;
+    }
+    isArrayValue(key, value) {
+        return !this.OPERATORS.includes(key) && Array.isArray(value);
+    }
+    isLogicalOperator(key) {
+        return ['$or', '$and'].includes(key);
+    }
+    isNorOperator(key) {
+        return key === '$nor';
+    }
+    extractLogicalOperator(key) {
+        return key.toUpperCase().replace('$', '');
+    }
+    trackLastNonOperatorKey(key) {
+        if (!this.OPERATORS.includes(key)) {
+            this.lastKeyNotOperator = key;
+        }
+    }
+    resolveColumnName(property) {
+        if (property.startsWith('$')) {
+            return property;
+        }
+        const column = this.columnMap[property];
+        if (column) {
+            return column;
+        }
+        return (0, utils_1.toSnakeCase)(property);
+    }
+    buildNullCondition(column, operator) {
+        if (operator === '!=' || operator === '<>')
+            return `${column} IS NOT NULL`;
+        return `${column} IS NULL`;
+    }
+}
+exports.IndexConditionBuilder = IndexConditionBuilder;

package/dist/query/model-transformer.d.ts

@@ -0,0 +1,27 @@
+import { Statement } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+export declare class ModelTransformer {
+    private entityStorage;
+    constructor(entityStorage: EntityStorage);
+    transform<T>(model: any, statement: Statement<any>, data: any): T;
+    private registerInstancesInIdentityMap;
+    private createInstances;
+    private createInstance;
+    private addJoinedInstances;
+    private extractPrimaryKeyFromData;
+    private extractPrimaryKeyValue;
+    private getPrimaryKeyFromData;
+    private findPrimaryKeyProperty;
+    private buildOptionsMap;
+    private populateProperties;
+    private parseColumnKey;
+    private setPropertyValue;
+    private findPropertyByColumnName;
+    private isValueObjectType;
+    private linkJoinedEntities;
+    private linkSingleJoin;
+    private findRelationProperty;
+    private attachJoinedEntity;
+    private appendToArray;
+    private resetChangedValues;
+}

package/dist/query/model-transformer.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelTransformer = void 0;
+const value_object_1 = require("../common/value-object");
+const utils_1 = require("../utils");
+const identity_map_1 = require("../identity-map");
+class ModelTransformer {
+    constructor(entityStorage) {
+        this.entityStorage = entityStorage;
+    }
+    transform(model, statement, data) {
+        const { instanceMap, cachedAliases } = this.createInstances(model, statement, data);
+        const optionsMap = this.buildOptionsMap(instanceMap);
+        this.populateProperties(data, instanceMap, optionsMap, cachedAliases);
+        this.linkJoinedEntities(statement, instanceMap, optionsMap);
+        this.resetChangedValues(instanceMap, cachedAliases);
+        this.registerInstancesInIdentityMap(instanceMap, cachedAliases);
+        return instanceMap[statement.alias];
+    }
+    registerInstancesInIdentityMap(instanceMap, cachedAliases) {
+        Object.entries(instanceMap).forEach(([alias, instance]) => {
+            // Skip registering entities that were already in cache
+            if (cachedAliases.has(alias)) {
+                return;
+            }
+            identity_map_1.IdentityMapIntegration.registerEntity(instance);
+        });
+    }
+    createInstances(model, statement, data) {
+        const cachedAliases = new Set();
+        const primaryKey = this.extractPrimaryKeyFromData(model, statement.alias, data);
+        const { instance, wasCached } = this.createInstance(model, primaryKey);
+        if (wasCached) {
+            cachedAliases.add(statement.alias);
+        }
+        const instanceMap = {
+            [statement.alias]: instance,
+        };
+        if (statement.join) {
+            this.addJoinedInstances(statement, instanceMap, data, cachedAliases);
+        }
+        return { instanceMap, cachedAliases };
+    }
+    createInstance(model, primaryKey) {
+        const cached = identity_map_1.IdentityMapIntegration.getEntity(model, primaryKey);
+        if (cached) {
+            return { instance: cached, wasCached: true };
+        }
+        const instance = new model();
+        instance.$_isPersisted = true;
+        // Note: Registration happens later in registerInstancesInIdentityMap after properties are populated
+        return { instance, wasCached: false };
+    }
+    addJoinedInstances(statement, instanceMap, data, cachedAliases) {
+        statement.join.forEach(join => {
+            const primaryKey = this.extractPrimaryKeyFromData(join.joinEntity, join.joinAlias, data);
+            const { instance: joinInstance, wasCached } = this.createInstance(join.joinEntity, primaryKey);
+            if (wasCached) {
+                cachedAliases.add(join.joinAlias);
+            }
+            instanceMap[join.joinAlias] = joinInstance;
+        });
+    }
+    extractPrimaryKeyFromData(model, alias, data) {
+        const options = this.entityStorage.get(model);
+        if (!options) {
+            return undefined;
+        }
+        return this.extractPrimaryKeyValue(options, alias, data);
+    }
+    extractPrimaryKeyValue(options, alias, data) {
+        const pkProperty = this.findPrimaryKeyProperty(options);
+        if (!pkProperty) {
+            return undefined;
+        }
+        return this.getPrimaryKeyFromData(pkProperty, alias, data);
+    }
+    getPrimaryKeyFromData(pkProperty, alias, data) {
+        const pkColumnName = pkProperty.options.columnName;
+        const pkKey = `${alias}_${pkColumnName}`;
+        return data[pkKey];
+    }
+    findPrimaryKeyProperty(options) {
+        for (const prop in options.properties) {
+            if (options.properties[prop].options.isPrimary) {
+                return options.properties[prop];
+            }
+        }
+        return null;
+    }
+    buildOptionsMap(instanceMap) {
+        const optionsMap = new Map();
+        for (const [alias, instance] of Object.entries(instanceMap)) {
+            const options = this.entityStorage.get(instance.constructor);
+            if (options) {
+                optionsMap.set(alias, options);
+            }
+        }
+        return optionsMap;
+    }
+    populateProperties(data, instanceMap, optionsMap, cachedAliases) {
+        Object.entries(data).forEach(([key, value]) => {
+            const { alias, propertyName } = this.parseColumnKey(key);
+            const entity = instanceMap[alias];
+            if (!entity) {
+                return;
+            }
+            // Skip populating properties for cached entities to preserve in-memory changes
+            if (cachedAliases.has(alias)) {
+                return;
+            }
+            this.setPropertyValue(entity, propertyName, value, optionsMap.get(alias));
+        });
+    }
+    parseColumnKey(key) {
+        const index = key.indexOf('_');
+        return {
+            alias: key.substring(0, index),
+            propertyName: key.substring(index + 1),
+        };
+    }
+    setPropertyValue(entity, columnName, value, options) {
+        const propertyInfo = this.findPropertyByColumnName(columnName, options);
+        if (!propertyInfo) {
+            return;
+        }
+        const { key, property } = propertyInfo;
+        if (this.isValueObjectType(property.type)) {
+            entity[key] = new property.type(value);
+            return;
+        }
+        entity[key] = value;
+    }
+    findPropertyByColumnName(columnName, options) {
+        // First, try to find in regular properties
+        const entry = Object.entries(options.properties).find(([_, prop]) => prop.options.columnName === columnName);
+        if (entry) {
+            return { key: entry[0], property: entry[1] };
+        }
+        // If not found, try to find in relations (many-to-one)
+        const relation = options.relations?.find((rel) => rel.columnName === columnName && rel.relation === 'many-to-one');
+        if (relation) {
+            return { key: relation.propertyKey, property: relation };
+        }
+        return null;
+    }
+    isValueObjectType(type) {
+        return (0, utils_1.extendsFrom)(value_object_1.ValueObject, type?.prototype);
+    }
+    linkJoinedEntities(statement, instanceMap, optionsMap) {
+        if (!statement.join) {
+            return;
+        }
+        statement.join.forEach(join => {
+            this.linkSingleJoin(join, instanceMap, optionsMap);
+        });
+    }
+    linkSingleJoin(join, instanceMap, optionsMap) {
+        const { joinAlias, originAlias, propertyKey } = join;
+        const originEntity = instanceMap[originAlias];
+        const joinEntity = instanceMap[joinAlias];
+        if (!originEntity || !joinEntity) {
+            return;
+        }
+        const property = this.findRelationProperty(originAlias, propertyKey, optionsMap);
+        if (property) {
+            this.attachJoinedEntity(originEntity, joinEntity, propertyKey, property);
+        }
+    }
+    findRelationProperty(alias, propertyKey, optionsMap) {
+        return optionsMap.get(alias)?.relations.find(rel => rel.propertyKey === propertyKey);
+    }
+    attachJoinedEntity(originEntity, joinEntity, propertyKey, property) {
+        if (property.type === Array) {
+            originEntity[propertyKey] = this.appendToArray(originEntity[propertyKey], joinEntity);
+        }
+        else {
+            originEntity[propertyKey] = joinEntity;
+        }
+    }
+    appendToArray(existingArray, newItem) {
+        return existingArray ? [...existingArray, newItem] : [newItem];
+    }
+    resetChangedValues(instanceMap, cachedAliases) {
+        Object.entries(instanceMap).forEach(([alias, instance]) => {
+            // Skip resetting changed values for cached entities to preserve in-memory changes
+            if (cachedAliases.has(alias)) {
+                return;
+            }
+            const currentValues = {};
+            for (const key in instance) {
+                if (!key.startsWith('_') && !key.startsWith('$')) {
+                    currentValues[key] = instance[key];
+                }
+            }
+            instance._oldValues = currentValues;
+            instance._changedValues = {};
+        });
+    }
+}
+exports.ModelTransformer = ModelTransformer;

package/dist/query/sql-column-manager.d.ts

@@ -0,0 +1,28 @@
+import { Statement } from '../driver/driver.interface';
+import { EntityStorage, Options } from '../domain/entities';
+export declare class SqlColumnManager {
+    private entityStorage;
+    private statements;
+    private entity;
+    constructor(entityStorage: EntityStorage, statements: Statement<any>, entity: Options);
+    generateColumns(model: Function, updatedColumns: string[]): string[];
+    processUserColumns(columns: string[]): string[];
+    getColumnsForEntity(entity: Function, alias: string): string[];
+    discoverAlias(column: string, onlyAlias?: boolean): string | undefined;
+    private getJoinColumns;
+    private getPropertyColumns;
+    private getRelationColumns;
+    private extractAliases;
+    private filterValid;
+    private isNestedColumn;
+    private buildSimpleColumnAlias;
+    private buildNestedColumnAlias;
+    private validateJoinsExist;
+    private resolveNestedAlias;
+    private buildJoinMaps;
+    private findNextAlias;
+    private formatColumnWithAlias;
+    private getColumnNameFromProperty;
+    private getColumnNameFromPropertyForEntity;
+    private getEntityFromAlias;
+}

package/dist/query/sql-column-manager.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlColumnManager = void 0;
+class SqlColumnManager {
+    constructor(entityStorage, statements, entity) {
+        this.entityStorage = entityStorage;
+        this.statements = statements;
+        this.entity = entity;
+    }
+    generateColumns(model, updatedColumns) {
+        const baseColumns = this.getColumnsForEntity(model, this.statements.alias);
+        const joinColumns = this.getJoinColumns();
+        const allColumns = [...baseColumns, ...joinColumns];
+        return [...allColumns, ...updatedColumns];
+    }
+    processUserColumns(columns) {
+        const aliasedColumns = this.extractAliases(columns);
+        return this.filterValid(aliasedColumns);
+    }
+    getColumnsForEntity(entity, alias) {
+        const entityOptions = this.entityStorage.get(entity);
+        if (!entityOptions) {
+            throw new Error('Entity not found');
+        }
+        const propertyColumns = this.getPropertyColumns(entityOptions, alias);
+        const relationColumns = this.getRelationColumns(entityOptions, alias);
+        return [...propertyColumns, ...relationColumns];
+    }
+    discoverAlias(column, onlyAlias = false) {
+        if (!this.isNestedColumn(column)) {
+            return this.buildSimpleColumnAlias(column, this.statements.alias, onlyAlias);
+        }
+        return this.buildNestedColumnAlias(column, onlyAlias);
+    }
+    getJoinColumns() {
+        if (!this.statements.join) {
+            return [];
+        }
+        return this.statements.join.flatMap(join => this.getColumnsForEntity(join.joinEntity, join.joinAlias));
+    }
+    getPropertyColumns(entityOptions, alias) {
+        return Object.keys(entityOptions.properties).map(key => {
+            const columnName = entityOptions.properties[key].options.columnName;
+            return `${alias}."${columnName}" as "${alias}_${columnName}"`;
+        });
+    }
+    getRelationColumns(entityOptions, alias) {
+        if (!entityOptions.relations) {
+            return [];
+        }
+        return entityOptions.relations
+            .filter(relation => relation.relation === 'many-to-one')
+            .map(relation => `${alias}."${relation.columnName}" as "${alias}_${relation.columnName}"`);
+    }
+    extractAliases(columns) {
+        return columns
+            .map(column => this.discoverAlias(column))
+            .flat()
+            .filter((col) => col !== undefined);
+    }
+    filterValid(columns) {
+        return columns.filter(Boolean);
+    }
+    isNestedColumn(column) {
+        return column.includes('.');
+    }
+    buildSimpleColumnAlias(column, alias, onlyAlias) {
+        const columnName = this.getColumnNameFromProperty(column);
+        if (onlyAlias) {
+            return `${alias}."${columnName}"`;
+        }
+        return `${alias}."${columnName}" as ${alias}_${columnName}`;
+    }
+    buildNestedColumnAlias(column, onlyAlias) {
+        this.validateJoinsExist();
+        const parts = column.split('.');
+        const aliasInfo = this.resolveNestedAlias(parts);
+        if (!aliasInfo) {
+            return undefined;
+        }
+        return this.formatColumnWithAlias(aliasInfo.alias, parts[parts.length - 1], onlyAlias);
+    }
+    validateJoinsExist() {
+        if (!this.statements.join && !this.statements.selectJoin) {
+            throw new Error('Join not found');
+        }
+    }
+    resolveNestedAlias(parts) {
+        const joinMaps = this.buildJoinMaps();
+        let currentAlias = this.statements.alias;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLastPart = i === parts.length - 1;
+            if (isLastPart) {
+                return { alias: currentAlias };
+            }
+            const nextAlias = this.findNextAlias(part, joinMaps, i === 0);
+            if (!nextAlias) {
+                return null;
+            }
+            currentAlias = nextAlias;
+        }
+        return { alias: currentAlias };
+    }
+    buildJoinMaps() {
+        const relationsMap = new Map(this.entity.relations.map(rel => [rel.propertyKey, rel]));
+        const joinMap = new Map();
+        this.statements.join?.forEach(join => joinMap.set(join.joinProperty, join));
+        const selectJoinMap = new Map();
+        this.statements.selectJoin?.forEach(join => selectJoinMap.set(join.joinProperty, join));
+        return { joinMap, selectJoinMap, relationsMap };
+    }
+    findNextAlias(part, maps, isFirstPart) {
+        if (maps.joinMap.has(part)) {
+            return maps.joinMap.get(part).joinAlias;
+        }
+        if (maps.selectJoinMap.has(part)) {
+            return null;
+        }
+        return null;
+    }
+    formatColumnWithAlias(alias, propertyName, onlyAlias) {
+        const entity = this.getEntityFromAlias(alias);
+        const columnName = this.getColumnNameFromPropertyForEntity(propertyName, entity);
+        if (onlyAlias) {
+            return `${alias}."${columnName}"`;
+        }
+        return `${alias}."${columnName}" as ${alias}_${columnName}`;
+    }
+    getColumnNameFromProperty(propertyName) {
+        return this.getColumnNameFromPropertyForEntity(propertyName, this.entity);
+    }
+    getColumnNameFromPropertyForEntity(propertyName, entity) {
+        if (entity.properties[propertyName]) {
+            return entity.properties[propertyName].options.columnName;
+        }
+        const relation = entity.relations?.find(rel => rel.propertyKey === propertyName);
+        if (relation) {
+            return relation.columnName;
+        }
+        return propertyName;
+    }
+    getEntityFromAlias(alias) {
+        if (alias === this.statements.alias) {
+            return this.entity;
+        }
+        const join = this.statements.join?.find(j => j.joinAlias === alias);
+        if (join?.joinEntity) {
+            const entity = this.entityStorage.get(join.joinEntity);
+            if (entity) {
+                return entity;
+            }
+        }
+        return this.entity;
+    }
+}
+exports.SqlColumnManager = SqlColumnManager;