@entity-access/entity-access 1.1.16 → 1.1.18

package/src/compiler/sql-server/SqlServerSqlMethodTransformer.ts

@@ -1,5 +1,5 @@
 
-import { joinAny, joinMap, prepareAny } from "../../query/ast/IStringTransformer.js";
+import { expandParamArray, joinAny, joinMap, prepareAny } from "../../query/ast/IStringTransformer.js";
 import Sql from "../../sql/Sql.js";
 import { ISqlHelpers, flattenMethods } from "../ISqlHelpers.js";
 
@@ -281,8 +281,14 @@ export const SqlServerSqlHelper: ISqlHelpers = {
         iLike(text, test) {
             return prepareAny `(${text} like ${test})`;
         },
-        iLikeAny(text, test) {
-            return ["(", (x)=> joinMap(" OR ", x, test, (item) => [ "(" , text, " like ", () => item , ")" ]), ")"] as any;
+        iLikeAny(text, input) {
+            return expandParamArray({
+                input,
+                sep: " OR ",
+                prefix: ["("],
+                fx: (item) => ["(", text, " like ", () => item, ")" ] as any,
+                suffix: [")"]
+            });
         },
         indexOf(text, test) {
             return prepareAny `(CHARINDEX(${test}, ${text}) - 1)`;

package/src/migrations/Migrations.ts

@@ -90,6 +90,17 @@ export default abstract class Migrations {
                 await this.enableGeoSpatialTypes();
             }
 
+            // for (const index of type.indexes) {
+            //     for (const column of index.columns) {
+            //         const c = type.getProperty(column.name);
+            //         if (c.field) {
+            //             column.name = c.field.columnName;
+            //         } else {
+            //             debugger;
+            //         }
+            //     }
+            // }
+
             const schema = await this.getSchema(type);
 
             await this.migrateTable(context, type);
@@ -217,12 +228,14 @@ export default abstract class Migrations {
         }
 
 
-        for (const column of index.columns) {
-            const c = type.getProperty(column.name);
-            if (c.field) {
-                column.name = c.field.columnName;
-            }
-        }
+        // for (const column of index.columns) {
+        //     const c = type.getProperty(column.name);
+        //     if (c.field) {
+        //         column.name = c.field.columnName;
+        //     } else {
+        //         debugger;
+        //     }
+        // }
 
         if (index.include) {
             index.include = index.include.map((c) => type.getProperty(c).field.columnName);

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

@@ -32,7 +32,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
                 : "";
             const indexDef: IIndex = {
                 name: `IX_${type.name}_${iterator.name}`,
-                columns: [{ name: iterator.quotedColumnName, descending: iterator.indexOrder !== "ascending"}],
+                columns: [{ name: iterator.columnName, descending: iterator.indexOrder !== "ascending"}],
                 filter
             };
             await this.migrateIndexInternal(context, indexDef, type);
@@ -123,15 +123,27 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
             : type.name;
         const indexName =  index.name;
         const columns = [];
-        let spatial = true;
+        let spatial = false;
+        let nonSpatial = false;
         for (const column of index.columns) {
             const columnName = column.name;
             const c = type.getColumn(column.name);
             const isColumnSpatial = isSpatialType(c.dataType);
-            spatial &&= isColumnSpatial;
+            if (isColumnSpatial) {
+                spatial ||= true;
+            } else {
+                nonSpatial ||= true;
+            }
             columns.push(`${columnName} ${ isSpatialType(c.dataType) ? "" : (column.descending ? "DESC" : "ASC")}`);
         }
 
+        if (spatial) {
+            if (nonSpatial) {
+                console.warn(`SQL SERVER DOEST NOT SUPPORT SPATIAL AND OTHER DATATYPE INDEX so ${name} index is not created`);
+                return;
+            }
+        }
+
         const indexType = spatial ? " SPATIAL " : "";
 
         let query = `IF NOT EXISTS(SELECT * FROM sys.indexes WHERE name = '${indexName}' AND object_id = OBJECT_ID('${name}'))

package/src/model/EntityModel.ts

@@ -44,6 +44,17 @@ const getOrCreateModel = (map: Map<any, EntityType>, type: IClassOf<any>, compil
     if (t.keys.length > 1) {
         t.keys.sort((a, b) => a.order - b.order);
     }
+
+    for(const index of t.indexes) {
+        for (const column of index.columns) {
+            const c = t.getProperty(column.name);
+            if (c.field) {
+                column.name = c.field.columnName;
+            } else {
+                debugger;
+            }
+        }
+    }
     for (const iterator of original.relations) {
         if (!iterator.relatedTypeClass) {
             iterator.relatedTypeClass = iterator.relatedTypeClassFactory();

package/src/query/ast/IStringTransformer.ts

@@ -20,6 +20,37 @@ export class QueryParameter {
     }
 }
 
+export const expandParamArray = ({
+    sep = ",",
+    input,
+    prefix = [],
+    suffix = [],
+    emptyResult = [" false "],
+    fx = (xi) => [() => xi]
+}) => [(p) => {
+    const a = input[0](p);
+    if (!a.length) {
+        return emptyResult;
+    }
+    const r = prefix;
+    let s = "";
+    for (const iterator of a) {
+        if (s) {
+            r.push(s);
+        }
+        s = sep;
+        const items = fx(iterator).flat(2);
+        for (const fi of items) {
+            r.push(fi);
+        }
+    }
+    for(const sx of suffix) {
+        r.push(sx);
+    }
+    return r.flat(2);
+}] as any;
+
+
 export const joinMap = (sep: string, input, a: any, fx: ((item) => any) = (xi) => [() => xi]) => {
     const r = [];
     a = (Array.isArray(a) ? a.map((x) => x(input)) : a(input)).flat(2);