@entity-access/entity-access 1.0.461 → 1.0.462

package/src/migrations/sql-server/SqlServerAutomaticMigrations.ts

@@ -45,11 +45,11 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
     async createIndexes(context: EntityContext, type: EntityType, fkColumns: IColumn[]) {
         for (const iterator of fkColumns) {
             const filter = iterator.nullable
-                ? `${ iterator.columnName} IS NOT NULL`
+                ? `${ iterator.quotedColumnName} IS NOT NULL`
                 : "";
             const indexDef: IIndex = {
                 name: `IX_${type.name}_${iterator.name}`,
-                columns: [{ name: iterator.columnName, descending: iterator.indexOrder !== "ascending"}],
+                columns: [{ name: iterator.quotedColumnName, descending: iterator.indexOrder !== "ascending"}],
                 filter
             };
             await this.migrateIndex(context, indexDef, type);
@@ -67,7 +67,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         }
 
         for (const iterator of nonKeyColumns) {
-            const columnName = iterator.columnName;
+            const columnName = iterator.quotedColumnName;
             let def = `IF COL_LENGTH(${ SqlServerLiteral.escapeLiteral(name)}, ${ SqlServerLiteral.escapeLiteral(columnName)}) IS NULL ALTER TABLE ${name} ADD ${columnName} `;
 
             if (iterator.computed) {
@@ -106,7 +106,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         const fields = [];
 
         for (const iterator of keys) {
-            let def = iterator.columnName + " ";
+            let def = iterator.quotedColumnName + " ";
             if (iterator.generated) {
                 switch(iterator.generated) {
                     case "identity":
@@ -122,7 +122,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
 
         await driver.executeQuery(`IF OBJECT_ID(${ SqlServerLiteral.escapeLiteral(name)}) IS NULL BEGIN
             CREATE TABLE ${name} (${fields.join(",")}
-            , CONSTRAINT PK_${name} PRIMARY KEY(${keys.map((x) => x.columnName)})
+            , CONSTRAINT PK_${name} PRIMARY KEY(${keys.map((x) => x.quotedColumnName)})
             );
         END`);
 
@@ -183,9 +183,9 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         const driver = context.connection;
 
         let text = `ALTER TABLE ${name} ADD CONSTRAINT ${constraint.name} 
-            foreign key (${constraint.fkMap.map((x) => x.fkColumn.columnName).join(",")})
+            foreign key (${constraint.fkMap.map((x) => x.fkColumn.quotedColumnName).join(",")})
             references ${constraint.fkMap[0].relatedKeyColumn.entityType.name}(
-                ${constraint.fkMap.map((x) => x.relatedKeyColumn.columnName).join(",")}
+                ${constraint.fkMap.map((x) => x.relatedKeyColumn.quotedColumnName).join(",")}
             ) `;
 
         switch(constraint.onDelete) {

package/src/model/EntityModel.ts

@@ -7,6 +7,7 @@ import EntityType from "../entity-query/EntityType.js";
 import { IStringTransformer } from "../query/ast/IStringTransformer.js";
 import { IEntityRelation } from "../decorators/IColumn.js";
 import type QueryCompiler from "../compiler/QueryCompiler.js";
+import { Expression } from "../query/ast/Expressions.js";
 
 const driverModelCache = Symbol("driverModelCache");
 
@@ -28,6 +29,8 @@ const getOrCreateModel = (map: Map<any, EntityType>, type: IClassOf<any>, compil
         column.entityType = t;
         column.quotedColumnName = quote(column.columnName);
         column.quotedName = quote(column.name);
+        column.quotedColumnNameExp = Expression.quotedIdentifier(column.columnName);
+        column.quotedNameExp = Expression.quotedIdentifier(column.name);
         t.addColumn(column);
     }
     t.indexes.push(... original.indexes.map((i) => ({ ... i, columns: [ ... i.columns.map((c) => ( { ... c}))] })));

package/src/model/EntityQuery.ts

@@ -78,11 +78,11 @@ export default class EntityQuery<T = any>
                     const propertyName = iterator.alias.value;
                     const column = type.getField(propertyName);
                     if (column) {
-                        fields.push(Expression.member(selectStatement.sourceParameter, Expression.quotedIdentifier(column.columnName)));
+                        fields.push(Expression.member(selectStatement.sourceParameter, column.quotedColumnNameExp));
                         modelFields.push(
                             Expression.member(
                             sourceParameter,
-                            Expression.quotedIdentifier(column.columnName))
+                            column.quotedColumnNameExp)
                         );
                         continue;
                     }
@@ -329,8 +329,8 @@ export default class EntityQuery<T = any>
         let where: Expression;
         for (const iterator of this.type.keys) {
             const compare = Expression.equal(
-                Expression.member(sp, Expression.quotedIdentifier(iterator.columnName)),
-                Expression.member(as, Expression.quotedIdentifier(iterator.columnName))
+                Expression.member(sp, iterator.quotedColumnNameExp),
+                Expression.member(as, iterator.quotedColumnNameExp)
             );
             where = where ? Expression.logicalAnd(where, compare) : compare;
         }
@@ -458,20 +458,20 @@ export default class EntityQuery<T = any>
             const eAs = iterator as ExpressionAs;
             const { field } = this.type.getProperty(eAs.alias.value);
             fieldMap.add(field.columnName);
-            set.push(Expression.assign(Expression.quotedIdentifier(field.columnName), Expression.member(as, Expression.quotedIdentifier(eAs.alias.value))));
+            set.push(Expression.assign(field.quotedColumnNameExp, Expression.member(as, Expression.quotedIdentifier(eAs.alias.value))));
         }
 
         let where = null as Expression;
         for (const iterator of this.type.keys) {
             const compare = Expression.equal(
-                Expression.member(as, Expression.quotedIdentifier(iterator.columnName)),
-                Expression.member(sp, Expression.quotedIdentifier(iterator.columnName))
+                Expression.member(as, iterator.quotedColumnNameExp),
+                Expression.member(sp, iterator.quotedColumnNameExp)
             );
             where = where ? Expression.logicalAnd(where, compare) : compare;
             if (fieldMap.has(iterator.columnName)) {
                 continue;
             }
-            this.selectStatement.fields.push(Expression.member(this.selectStatement.sourceParameter, Expression.quotedIdentifier(iterator.columnName)));
+            this.selectStatement.fields.push(Expression.member(this.selectStatement.sourceParameter, iterator.quotedColumnNameExp));
         }
 
         let returnUpdated = null as ExpressionAs[];
@@ -479,8 +479,8 @@ export default class EntityQuery<T = any>
             returnUpdated = [];
             for (const iterator of this.type.columns) {
                 returnUpdated.push(Expression.as(
-                    Expression.identifier(iterator.columnName),
-                    Expression.quotedIdentifier(iterator.name)
+                    iterator.quotedColumnNameExp,
+                    iterator.quotedNameExp
                 ));
             }
         }
@@ -550,7 +550,7 @@ export default class EntityQuery<T = any>
                             const column = type.getColumn((me.property as Identifier).value);
                             if (column) {
                                 fields.push(Expression.as(
-                                    Expression.member(select.sourceParameter, column.columnName)
+                                    Expression.member(select.sourceParameter, column.quotedColumnNameExp)
                                     , Expression.quotedIdentifier(column.name)));
                                 continue;
                             }

package/src/model/EntitySource.ts

@@ -264,7 +264,7 @@ export class EntitySource<T = any> {
         Object.setPrototypeOf(returnEntity, this.model.typeClass.prototype);
 
         for (const iterator of this.model.columns) {
-            returnFields.push(Expression.identifier(iterator.columnName));
+            returnFields.push(iterator.quotedColumnNameExp);
         }
 
         if (mode === "selectOrInsert" || mode === "upsert") {

package/src/query/ast/ExpressionToSql.ts

@@ -176,27 +176,6 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
     }
 
     visitCallExpression(e: CallExpression): ITextQuery {
-        // let us check if we are using any of array extension methods...
-        // .some alias .any
-        // .find alias .firstOrDefault
-        // if (e.callee.type === "MemberExpression") {
-        //     const me = e.callee as MemberExpression;
-        //     if (me.target.type === "CallExpression") {
-        //         // nested...
-        //         const ce = me.target as CallExpression;
-        //         const cme = ce.callee as MemberExpression;
-        //         if(cme.property.type !== "Identifier") {
-        //             throw new EntityAccessError("Invalid expression");
-        //         }
-        //         const property = cme.property as Identifier;
-        //         if(property.value !== "filter") {
-        //             throw new EntityAccessError("Invalid expression");
-        //         }
-
-        //         filter = e;
-        //         e = cme.target as CallExpression;
-        //     }
-        // }
 
         const targetProperty = this.getPropertyChain(e.callee as ExpressionType);
         if (targetProperty) {
@@ -308,16 +287,12 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         for (const { fkColumn, relatedKeyColumn } of relation.relation.relatedRelation.fkMap) {
             const targetKey = MemberExpression.create({
                 target: parameter,
-                property: Identifier.create({
-                    value: relatedKeyColumn.columnName
-                })
+                property: relatedKeyColumn.quotedColumnNameExp
             });
 
             const relatedKey = MemberExpression.create({
                 target: select.sourceParameter,
-                property: Identifier.create({
-                    value: fkColumn.columnName
-                })
+                property: fkColumn.quotedColumnNameExp
             });
             const join = Expression.equal(targetKey, relatedKey);
             where = where
@@ -363,16 +338,12 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
             const targetKey = MemberExpression.create({
                 target: parameter,
-                property: Identifier.create({
-                    value: relatedKeyColumn.columnName
-                })
+                property: relatedKeyColumn.quotedColumnNameExp
             });
 
             const relatedKey = MemberExpression.create({
                 target: param1,
-                property: Identifier.create({
-                    value: fkColumn.columnName
-                })
+                property: fkColumn.quotedColumnNameExp
             });
 
             const join = Expression.equal(targetKey, relatedKey);
@@ -438,7 +409,9 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 //     chain[0] = namingConvention(chain[0]);
                 // }
 
-                return [ QueryParameter.create(() => name) , "." , chain.map((x) => x.member).join(".")];
+                const quote = this.compiler.quote;
+
+                return [ QueryParameter.create(() => name) , "." , chain.map((x) => quote(x.member)).join(".")];
             }
         }
 
@@ -816,7 +789,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 const { relation, field } = peModel.getProperty(id.value);
                 if (field) {
                     // we need to replace field with column name...
-                    return Expression.member(target, field.columnName);
+                    return Expression.member(target, field.quotedColumnNameExp);
                 }
                 if (relation) {
 
@@ -854,8 +827,8 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                                 const peColumn = relation.isInverseRelation ? relatedKeyColumn : fkColumn;
                                 const joinColumn = relation.isInverseRelation ? fkColumn : relatedKeyColumn;
                                 const joinOn = Expression.equal(
-                                    Expression.member(pe, peColumn.columnName),
-                                    Expression.member(joinParameter, joinColumn.columnName));
+                                    Expression.member(pe, peColumn.quotedColumnNameExp),
+                                    Expression.member(joinParameter, joinColumn.quotedColumnNameExp));
                                 where = where
                                     ? Expression.logicalAnd(where, joinOn)
                                     : joinOn;

package/src/query/expander/QueryExpander.ts

@@ -133,8 +133,8 @@ export class QueryExpander {
                 const joinColumn = relatedKeyColumn;
                 const relatedColumn = fkColumn;
                 const joinOn = Expression.equal(
-                    Expression.member(joinParameter, Expression.identifier(joinColumn.columnName)),
-                    Expression.member(select.sourceParameter, Expression.identifier(relatedColumn.columnName))
+                    Expression.member(joinParameter, joinColumn.quotedColumnNameExp),
+                    Expression.member(select.sourceParameter, relatedColumn.quotedColumnNameExp)
                 );
                 where = where ? Expression.logicalAnd(where, joinOn) : joinOn;
             }
@@ -212,9 +212,9 @@ export class QueryExpander {
         for (const { fkColumn, relatedKeyColumn } of relation.fkMap) {
             const joinOn = Expression.equal(
                 Expression.member(selectJoinParameter,
-                    Expression.identifier(fkColumn.columnName)),
+                    fkColumn.quotedColumnNameExp),
                 Expression.member(select.sourceParameter,
-                    Expression.identifier(relatedKeyColumn.columnName))
+                    relatedKeyColumn.quotedColumnNameExp)
             );
             where = where ? Expression.logicalAnd(where, joinOn) : joinOn;
         }

package/test.js

@@ -145,15 +145,21 @@ let failed = 0;
 
 for (const { error, name } of results) {
     if (error) {
-        exitCode = 1;
-        failed++;
-        console.error(`${name} failed`);
-        console.error(error?.stack ?? error);
         continue;
     }
     console.log(`${name} executed.`);
 }
 
+for (const { error, name } of results) {
+    if (!error) {
+        continue;
+    }
+    exitCode = 1;
+    failed++;
+    console.error(`${name} failed`);
+    console.error(error?.stack ?? error);
+}
+
 if (exitCode === 0) {
     console.log(`${results.length} tests ran successfully.`);
 } else {