@carno.js/orm 1.0.6 → 1.0.8

package/dist/identity-map/entity-key-generator.js

@@ -21,16 +21,7 @@ class EntityKeyGenerator {
     }
     getPrimaryKeyName(entityClass) {
         const options = this.entityStorage.get(entityClass);
-        if (!options) {
-            return 'id';
-        }
-        for (const prop in options.properties) {
-            const property = options.properties[prop];
-            if (property.options.isPrimary) {
-                return prop;
-            }
-        }
-        return 'id';
+        return options?._primaryKeyPropertyName || 'id';
     }
     serializePrimaryKey(pk) {
         if (Array.isArray(pk)) {

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export { EntityStorage } from './domain/entities';
 export * from './driver/bun-pg.driver';
 export * from './driver/bun-mysql.driver';
 export * from './driver/bun-driver.base';
+export * from './driver/driver-factory';
 export * from './utils';
 export * from './driver/driver.interface';
 export * from './entry';

package/dist/index.js

@@ -33,6 +33,7 @@ Object.defineProperty(exports, "EntityStorage", { enumerable: true, get: functio
 __exportStar(require("./driver/bun-pg.driver"), exports);
 __exportStar(require("./driver/bun-mysql.driver"), exports);
 __exportStar(require("./driver/bun-driver.base"), exports);
+__exportStar(require("./driver/driver-factory"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./driver/driver.interface"), exports);
 __exportStar(require("./entry"), exports);

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

@@ -18,6 +18,7 @@ export declare class ModelTransformer {
     private populateProperties;
     private parseColumnKey;
     private setPropertyValue;
+    private normalizePropertyValue;
     private findPropertyByColumnName;
     private isValueObjectType;
     private linkJoinedEntities;

package/dist/query/model-transformer.js

@@ -100,12 +100,8 @@ class ModelTransformer {
         return data[pkKey];
     }
     findPrimaryKeyProperty(options) {
-        for (const prop in options.properties) {
-            if (options.properties[prop].options.isPrimary) {
-                return options.properties[prop];
-            }
-        }
-        return null;
+        const pkPropertyName = options._primaryKeyPropertyName || 'id';
+        return options.properties[pkPropertyName] || null;
     }
     buildOptionsMap(instanceMap) {
         const optionsMap = new Map();
@@ -148,7 +144,25 @@ class ModelTransformer {
             entity[key] = new property.type(value);
             return;
         }
-        entity[key] = value;
+        entity[key] = this.normalizePropertyValue(property, value);
+    }
+    // @todo refactor for performance
+    normalizePropertyValue(property, value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (property?.type === Boolean) {
+            if (value === 1 || value === '1' || value === true || value === 'true') {
+                return true;
+            }
+            if (value === 0 || value === '0' || value === false || value === 'false') {
+                return false;
+            }
+        }
+        if (property?.type === Date && !(value instanceof Date)) {
+            return new Date(value);
+        }
+        return value;
     }
     findPropertyByColumnName(columnName, options) {
         // First, try to find in regular properties

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

@@ -1,10 +1,12 @@
-import { Statement } from '../driver/driver.interface';
+import { DriverInterface, 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);
+    private driver;
+    constructor(entityStorage: EntityStorage, statements: Statement<any>, entity: Options, driver: DriverInterface);
+    private quoteId;
     generateColumns(model: Function, updatedColumns: string[]): string[];
     processUserColumns(columns: string[]): string[];
     getColumnsForEntity(entity: Function, alias: string): string[];

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

@@ -2,10 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlColumnManager = void 0;
 class SqlColumnManager {
-    constructor(entityStorage, statements, entity) {
+    constructor(entityStorage, statements, entity, driver) {
         this.entityStorage = entityStorage;
         this.statements = statements;
         this.entity = entity;
+        this.driver = driver;
+    }
+    quoteId(identifier) {
+        const q = this.driver.getIdentifierQuote();
+        return `${q}${identifier}${q}`;
     }
     generateColumns(model, updatedColumns) {
         const baseColumns = this.getColumnsForEntity(model, this.statements.alias);
@@ -41,7 +46,9 @@ class SqlColumnManager {
     getPropertyColumns(entityOptions, alias) {
         return Object.keys(entityOptions.properties).map(key => {
             const columnName = entityOptions.properties[key].options.columnName;
-            return `${alias}."${columnName}" as "${alias}_${columnName}"`;
+            const col = this.quoteId(columnName);
+            const aliasedCol = this.quoteId(`${alias}_${columnName}`);
+            return `${alias}.${col} as ${aliasedCol}`;
         });
     }
     getRelationColumns(entityOptions, alias) {
@@ -50,7 +57,11 @@ class SqlColumnManager {
         }
         return entityOptions.relations
             .filter(relation => relation.relation === 'many-to-one')
-            .map(relation => `${alias}."${relation.columnName}" as "${alias}_${relation.columnName}"`);
+            .map(relation => {
+            const col = this.quoteId(relation.columnName);
+            const aliasedCol = this.quoteId(`${alias}_${relation.columnName}`);
+            return `${alias}.${col} as ${aliasedCol}`;
+        });
     }
     extractAliases(columns) {
         return columns
@@ -66,10 +77,11 @@ class SqlColumnManager {
     }
     buildSimpleColumnAlias(column, alias, onlyAlias) {
         const columnName = this.getColumnNameFromProperty(column);
+        const col = this.quoteId(columnName);
         if (onlyAlias) {
-            return `${alias}."${columnName}"`;
+            return `${alias}.${col}`;
         }
-        return `${alias}."${columnName}" as ${alias}_${columnName}`;
+        return `${alias}.${col} as ${alias}_${columnName}`;
     }
     buildNestedColumnAlias(column, onlyAlias) {
         this.validateJoinsExist();
@@ -122,10 +134,11 @@ class SqlColumnManager {
     formatColumnWithAlias(alias, propertyName, onlyAlias) {
         const entity = this.getEntityFromAlias(alias);
         const columnName = this.getColumnNameFromPropertyForEntity(propertyName, entity);
+        const col = this.quoteId(columnName);
         if (onlyAlias) {
-            return `${alias}."${columnName}"`;
+            return `${alias}.${col}`;
         }
-        return `${alias}."${columnName}" as ${alias}_${columnName}`;
+        return `${alias}.${col} as ${alias}_${columnName}`;
     }
     getColumnNameFromProperty(propertyName) {
         return this.getColumnNameFromPropertyForEntity(propertyName, this.entity);

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

@@ -1,4 +1,4 @@
-import { FilterQuery, Relationship, Statement } from '../driver/driver.interface';
+import { DriverInterface, FilterQuery, Relationship, Statement } from '../driver/driver.interface';
 import { EntityStorage } from '../domain/entities';
 import { SqlSubqueryBuilder } from './sql-subquery-builder';
 type ApplyJoinCallback = (relationship: Relationship<any>, value: FilterQuery<any>, alias: string) => string;
@@ -6,9 +6,10 @@ export declare class SqlConditionBuilder<T> {
     private entityStorage;
     private applyJoinCallback;
     private statements;
+    private driver;
     private lastKeyNotOperator;
     private subqueryBuilder?;
-    constructor(entityStorage: EntityStorage, applyJoinCallback: ApplyJoinCallback, statements: Statement<T>);
+    constructor(entityStorage: EntityStorage, applyJoinCallback: ApplyJoinCallback, statements: Statement<T>, driver: DriverInterface);
     setSubqueryBuilder(subqueryBuilder: SqlSubqueryBuilder): void;
     build(condition: FilterQuery<T>, alias: string, model: Function): string;
     private processConditions;
@@ -30,6 +31,7 @@ export declare class SqlConditionBuilder<T> {
     private extractValueFromValueObject;
     private formatValue;
     private formatDate;
+    private formatDateForMysql;
     private isNullish;
     private buildNullCondition;
     private isPrimitive;

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

@@ -12,10 +12,11 @@ const OPERATORS_SET = new Set([
 const LOGICAL_OPERATORS_SET = new Set(['$or', '$and']);
 const PRIMITIVES_SET = new Set(['string', 'number', 'boolean', 'bigint']);
 class SqlConditionBuilder {
-    constructor(entityStorage, applyJoinCallback, statements) {
+    constructor(entityStorage, applyJoinCallback, statements, driver) {
         this.entityStorage = entityStorage;
         this.applyJoinCallback = applyJoinCallback;
         this.statements = statements;
+        this.driver = driver;
         this.lastKeyNotOperator = '';
     }
     setSubqueryBuilder(subqueryBuilder) {
@@ -178,7 +179,17 @@ class SqlConditionBuilder {
         return this.formatJson(value);
     }
     formatDate(value) {
-        return `'${value.toISOString()}'`;
+        const formatted = this.driver.dbType === 'mysql'
+            ? this.formatDateForMysql(value)
+            : value.toISOString();
+        return `'${formatted}'`;
+    }
+    formatDateForMysql(value) {
+        return value
+            .toISOString()
+            .replace('T', ' ')
+            .replace('Z', '')
+            .replace(/\.\d{3}/, '');
     }
     isNullish(value) {
         return value === null || value === undefined;

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

@@ -17,14 +17,18 @@ export declare class SqlJoinManager<T> {
     private getOriginalColumnsCallback;
     private getAliasCallback;
     constructor(entityStorage: EntityStorage, statements: Statement<T>, entity: Options, model: new () => T, driver: DriverInterface, logger: Logger, conditionBuilder: SqlConditionBuilder<T>, columnManager: SqlColumnManager, modelTransformer: ModelTransformer, getOriginalColumnsCallback: () => string[], getAliasCallback: (tableName: string) => string);
+    private quoteId;
+    private qualifyTable;
     addJoinForRelationshipPath(relationshipPath: string): void;
     applyJoin(relationShip: Relationship<any>, value: FilterQuery<any>, alias: string): string;
     handleSelectJoin(entities: any, models: any): Promise<void>;
+    handleSelectJoinBatch(entities: any[], models: any[]): Promise<void>;
     getPathForSelectJoin(selectJoin: Statement<any>): string[] | null;
     private buildJoinOn;
     private addJoinedJoin;
     private addSelectJoin;
     private processSelectJoin;
+    private processSelectJoinBatch;
     private getIds;
     private updateJoinWhere;
     private updateJoinColumns;

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

@@ -15,6 +15,16 @@ class SqlJoinManager {
         this.getOriginalColumnsCallback = getOriginalColumnsCallback;
         this.getAliasCallback = getAliasCallback;
     }
+    quoteId(identifier) {
+        const q = this.driver.getIdentifierQuote();
+        return `${q}${identifier}${q}`;
+    }
+    qualifyTable(schema, tableName) {
+        if (this.driver.dbType === 'mysql') {
+            return this.quoteId(tableName);
+        }
+        return `${this.quoteId(schema)}.${this.quoteId(tableName)}`;
+    }
     addJoinForRelationshipPath(relationshipPath) {
         const relationshipNames = relationshipPath.split('.');
         let currentEntity = this.entity;
@@ -69,18 +79,29 @@ class SqlJoinManager {
         }
         return models;
     }
+    async handleSelectJoinBatch(entities, models) {
+        if (!this.statements.selectJoin || this.statements.selectJoin.length === 0) {
+            return;
+        }
+        for (const join of this.statements.selectJoin.reverse()) {
+            await this.processSelectJoinBatch(join, entities, models);
+        }
+    }
     getPathForSelectJoin(selectJoin) {
         const path = this.getPathForSelectJoinRecursive(selectJoin);
         return path.reverse();
     }
     buildJoinOn(relationShip, alias, joinAlias, originPrimaryKey) {
         let on = '';
+        const fkKey = this.quoteId(this.getFkKey(relationShip));
+        const pk = this.quoteId(originPrimaryKey);
         switch (relationShip.relation) {
             case "one-to-many":
-                on = `${joinAlias}."${this.getFkKey(relationShip)}" = ${alias}."${originPrimaryKey}"`;
+                on = `${joinAlias}.${fkKey} = ${alias}.${pk}`;
                 break;
             case "many-to-one":
-                on = `${alias}."${relationShip.columnName}" = ${joinAlias}."${this.getFkKey(relationShip)}"`;
+                const col = this.quoteId(relationShip.columnName);
+                on = `${alias}.${col} = ${joinAlias}.${fkKey}`;
                 break;
         }
         return on;
@@ -109,7 +130,7 @@ class SqlJoinManager {
         this.statements.selectJoin.push({
             statement: 'select',
             columns: this.getOriginalColumnsCallback().filter(column => column.startsWith(`${relationShip.propertyKey}`)).map(column => column.split('.')[1]) || [],
-            table: `"${joinSchema || 'public'}"."${joinTableName}"`,
+            table: this.qualifyTable(joinSchema || 'public', joinTableName),
             alias: joinAlias,
             where: joinWhere,
             joinProperty: relationShip.propertyKey,
@@ -133,6 +154,35 @@ class SqlJoinManager {
         this.logger.debug(`SQL: ${child.sql} [${Date.now() - child.startTime}ms]`);
         this.attachJoinResults(join, child, models);
     }
+    async processSelectJoinBatch(join, entities, models) {
+        const allIds = new Set();
+        for (let i = 0; i < entities.length; i++) {
+            const ids = this.getIds(join, entities[i], models[i]);
+            if (Array.isArray(ids)) {
+                ids.forEach(id => {
+                    if (id !== undefined && id !== null) {
+                        allIds.add(id);
+                    }
+                });
+            }
+            else if (ids !== undefined && ids !== null) {
+                allIds.add(ids);
+            }
+        }
+        if (allIds.size === 0) {
+            return;
+        }
+        const idsString = Array.from(allIds)
+            .map((id) => this.formatValue(id))
+            .join(', ');
+        this.updateJoinWhere(join, idsString);
+        this.updateJoinColumns(join);
+        const result = await this.driver.executeStatement(join);
+        this.logger.debug(`SQL (BATCHED): ${result.sql} [${Date.now() - result.startTime}ms]`);
+        for (let i = 0; i < entities.length; i++) {
+            this.attachJoinResults(join, result, models[i]);
+        }
+    }
     getIds(join, entities, models) {
         let ids = entities[`${join.originAlias}_${join.primaryKey}`];
         if (typeof ids === 'undefined') {
@@ -145,16 +195,21 @@ class SqlJoinManager {
         return ids;
     }
     updateJoinWhere(join, ids) {
+        const fkCol = this.quoteId(join.fkKey);
         if (join.where) {
-            join.where = `${join.where} AND ${join.alias}."${join.fkKey}" IN (${ids})`;
+            join.where = `${join.where} AND ${join.alias}.${fkCol} IN (${ids})`;
         }
         else {
-            join.where = `${join.alias}."${join.fkKey}" IN (${ids})`;
+            join.where = `${join.alias}.${fkCol} IN (${ids})`;
         }
     }
     updateJoinColumns(join) {
         if (join.columns && join.columns.length > 0) {
-            join.columns = join.columns.map((column) => `${join.alias}."${column}" as "${join.alias}_${column}"`);
+            join.columns = join.columns.map((column) => {
+                const col = this.quoteId(column);
+                const aliasedCol = this.quoteId(`${join.alias}_${column}`);
+                return `${join.alias}.${col} as ${aliasedCol}`;
+            });
         }
         else {
             join.columns = this.columnManager.getColumnsForEntity(join.joinEntity, join.alias);
@@ -198,6 +253,11 @@ class SqlJoinManager {
     }
     getFkKey(relationShip) {
         if (typeof relationShip.fkKey === 'undefined') {
+            // Use cached primary key column name from the related entity instead of hardcoded 'id'
+            const relatedEntity = this.entityStorage.get(relationShip.entity());
+            if (relatedEntity) {
+                return relatedEntity._primaryKeyColumnName || 'id';
+            }
             return 'id';
         }
         if (typeof relationShip.fkKey === 'string') {
@@ -228,12 +288,7 @@ class SqlJoinManager {
         return { tableName, schema };
     }
     getPrimaryKey() {
-        for (const prop in this.entity.properties) {
-            if (this.entity.properties[prop].options.isPrimary) {
-                return prop;
-            }
-        }
-        return 'id';
+        return this.entity._primaryKeyPropertyName || 'id';
     }
     formatValue(value) {
         return (typeof value === 'string') ? `'${value}'` : value;

package/dist/query/sql-subquery-builder.d.ts

@@ -1,11 +1,14 @@
-import { FilterQuery, Relationship } from '../driver/driver.interface';
+import { DriverInterface, FilterQuery, Relationship } from '../driver/driver.interface';
 import { EntityStorage } from '../domain/entities';
 import { SqlConditionBuilder } from './sql-condition-builder';
 export declare class SqlSubqueryBuilder {
     private entityStorage;
     private getConditionBuilder;
+    private driver;
     private aliasCounter;
-    constructor(entityStorage: EntityStorage, getConditionBuilder: () => SqlConditionBuilder<any>);
+    constructor(entityStorage: EntityStorage, getConditionBuilder: () => SqlConditionBuilder<any>, driver: DriverInterface);
+    private quoteId;
+    private qualifyTable;
     buildExistsSubquery(relationship: Relationship<any>, filters: FilterQuery<any>, outerAlias: string, negate: boolean, outerModel?: Function): string;
     private buildSubquery;
     private buildWhereClause;

package/dist/query/sql-subquery-builder.js

@@ -2,11 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlSubqueryBuilder = void 0;
 class SqlSubqueryBuilder {
-    constructor(entityStorage, getConditionBuilder) {
+    constructor(entityStorage, getConditionBuilder, driver) {
         this.entityStorage = entityStorage;
         this.getConditionBuilder = getConditionBuilder;
+        this.driver = driver;
         this.aliasCounter = 1;
     }
+    quoteId(identifier) {
+        const q = this.driver.getIdentifierQuote();
+        return `${q}${identifier}${q}`;
+    }
+    qualifyTable(schema, tableName) {
+        if (this.driver.dbType === 'mysql') {
+            return this.quoteId(tableName);
+        }
+        return `${this.quoteId(schema)}.${this.quoteId(tableName)}`;
+    }
     buildExistsSubquery(relationship, filters, outerAlias, negate, outerModel) {
         const prefix = negate ? 'NOT EXISTS' : 'EXISTS';
         const subquery = this.buildSubquery(relationship, filters, outerAlias, outerModel);
@@ -28,10 +39,13 @@ class SqlSubqueryBuilder {
         const outerPkKey = this.getOuterPrimaryKey(relationship, outerModel);
         const relatedPkKey = this.getRelatedPrimaryKey(relationship);
         if (relationship.relation === 'one-to-many') {
-            return `${subqueryAlias}."${fkKey}" = ${outerAlias}."${outerPkKey}"`;
+            const fk = this.quoteId(fkKey);
+            const pk = this.quoteId(outerPkKey);
+            return `${subqueryAlias}.${fk} = ${outerAlias}.${pk}`;
         }
-        const outerFk = relationship.columnName;
-        return `${outerAlias}."${outerFk}" = ${subqueryAlias}."${relatedPkKey}"`;
+        const outerFk = this.quoteId(relationship.columnName);
+        const relatedPk = this.quoteId(relatedPkKey);
+        return `${outerAlias}.${outerFk} = ${subqueryAlias}.${relatedPk}`;
     }
     getOuterPrimaryKey(relationship, outerModel) {
         if (!outerModel) {
@@ -66,11 +80,11 @@ class SqlSubqueryBuilder {
         const entity = this.entityStorage.get(relationship.entity());
         if (!entity) {
             const name = relationship.entity().name.toLowerCase();
-            return `public.${name}`;
+            return this.qualifyTable('public', name);
         }
         const schema = entity.schema || 'public';
         const tableName = entity.tableName || relationship.entity().name.toLowerCase();
-        return `${schema}."${tableName}"`;
+        return this.qualifyTable(schema, tableName);
     }
     generateAlias() {
         const alias = `sq${this.aliasCounter}`;

package/dist/testing/with-database.d.ts

@@ -1,18 +1,20 @@
 import { Orm } from '../orm';
-import { BunPgDriver } from '../driver/bun-pg.driver';
-import { ConnectionSettings } from '../driver/driver.interface';
+import { ConnectionSettings, DriverInterface } from '../driver/driver.interface';
 import type { Logger } from '../logger';
+import { DriverType } from '../driver/driver-factory';
 export type DatabaseTestContext = {
-    orm: Orm<BunPgDriver>;
+    orm: Orm<DriverInterface>;
     executeSql: (sql: string) => Promise<{
         rows: unknown[];
     }>;
+    driverType: DriverType;
+    getDbType: () => 'postgres' | 'mysql';
 };
 export type DatabaseTestOptions = {
     schema?: string;
     entityFile?: string;
     logger?: Logger;
-    connection?: Partial<ConnectionSettings<BunPgDriver>>;
+    connection?: Partial<ConnectionSettings>;
 };
 type DatabaseTestRoutine = (context: DatabaseTestContext) => Promise<void>;
 export declare function withDatabase(tables: string[], routine: DatabaseTestRoutine, options?: DatabaseTestOptions): Promise<void>;