@entity-access/entity-access 1.0.348 → 1.0.350

package/src/drivers/base/BaseDriver.ts

@@ -262,16 +262,27 @@ export abstract class BaseDriver {
                     if(where) {
                         where += "\r\n\t\tAND ";
                     }
+                    const compare = keys[iterator.name];
+                    if (compare === null) {
+                        where += `${iterator.quotedColumnName} is null`;
+                        continue;
+                    }
                     where += `${iterator.quotedColumnName} = $${i++}`;
-                    values.push(keys[iterator.name]);
+                    values.push(compare);
                 }
             } else {
                 for (const iterator of type.keys) {
                     if(where) {
                         where += "\r\n\t\tAND ";
                     }
+                    const compare = entity[iterator.name];
+                    if (compare === null) {
+                        where += `${iterator.quotedColumnName} is null`;
+                        continue;
+                    }
+
                     where += `${iterator.quotedColumnName} = $${i++}`;
-                    values.push(entity[iterator.name]);
+                    values.push(compare);
                     continue;
                 }
             }
@@ -293,16 +304,26 @@ export abstract class BaseDriver {
                     if(where) {
                         where += "\r\n\t\tAND ";
                     }
+                    const compare = keys[iterator.name];
+                    if (compare === null) {
+                        where += `${iterator.quotedColumnName} is null`;
+                        continue;
+                    }
                     where += `${iterator.quotedColumnName} = $${i++}`;
-                    values.push(keys[iterator.name]);
+                    values.push(compare);
                 }
             } else {
                 for (const iterator of type.keys) {
                     if(where) {
                         where += "\r\n\t\tAND ";
                     }
+                    const compare = entity[iterator.name];
+                    if (compare === null) {
+                        where += `${iterator.quotedColumnName} is null`;
+                        continue;
+                    }
                     where += `${iterator.quotedColumnName} = $${i++}`;
-                    values.push(entity[iterator.name]);
+                    values.push(compare);
                 }
             }
         }
@@ -343,16 +364,27 @@ export abstract class BaseDriver {
                 if(where) {
                     where += "\r\n\t\tAND ";
                 }
+                const compare = keys[iterator.name];
+                if (compare === null) {
+                    where += `${iterator.quotedColumnName} is null`;
+                    continue;
+                }
+
                 where += `${iterator.quotedColumnName} = $${i++}`;
-                values.push(keys[iterator.name]);
+                values.push(compare);
             }
         } else {
             for (const iterator of type.keys) {
                 if(where) {
                     where += "\r\n\t\tAND ";
                 }
+                const compare = entity[iterator.name];
+                if (compare === null) {
+                    where += `${iterator.quotedColumnName} is null`;
+                    continue;
+                }
                 where += `${iterator.quotedColumnName} = $${i++}`;
-                values.push(entity[iterator.name]);
+                values.push(compare);
             }
         }
         const text = `SELECT ${columns}\r\n\tFROM ${type.fullyQualifiedTableName}\r\n\tWHERE ${where}`;

package/src/model/EntityQuery.ts

@@ -1,9 +1,10 @@
 import EntityAccessError from "../common/EntityAccessError.js";
 import Logger from "../common/Logger.js";
+import { modelSymbol } from "../common/symbols/symbols.js";
 import { AsyncDisposableScope } from "../common/usingAsync.js";
 import { IDbReader } from "../drivers/base/BaseDriver.js";
 import EntityType from "../entity-query/EntityType.js";
-import { BinaryExpression, CallExpression, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NumberLiteral, OrderByExpression, SelectStatement, TableLiteral, UpdateStatement } from "../query/ast/Expressions.js";
+import { BinaryExpression, CallExpression, DeleteStatement, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NumberLiteral, OrderByExpression, SelectStatement, TableLiteral, UpdateStatement } from "../query/ast/Expressions.js";
 import { QueryExpander } from "../query/expander/QueryExpander.js";
 import EntityContext from "./EntityContext.js";
 import type { EntitySource } from "./EntitySource.js";
@@ -31,29 +32,30 @@ export default class EntityQuery<T = any>
     }
 
     insertInTo(es: EntitySource) {
-        const model = (es as any).mode as EntityType;
-        const table = (es as any).model.fullyQualifiedName as TableLiteral;
-        const fields = [];
+        const model = es[modelSymbol] as EntityType;
+        const table = model.fullyQualifiedName as TableLiteral;
+        const fields = [] as string[];
         for (const iterator of this.selectStatement.fields) {
             if (iterator.type !== "ExpressionAs") {
-                fields.push(iterator);
-                continue;
+                throw new EntityAccessError(`as Expression expected instead of ${iterator.type}`);
             }
             const expAs = iterator as ExpressionAs;
             const field = model.getField(expAs.alias.value);
             if (!field) {
                 throw new EntityAccessError(`Field ${expAs.alias.value} not found in ${model.name}`);
             }
-            fields.push(Expression.as(expAs.expression, field.columnName));
+            fields.push(field.quotedColumnName);
         }
-        const values = { ... this.selectStatement, fields };
-        const query = InsertStatement.create({
-            table,
-            values
-        });
+        const query = { ... this.selectStatement };
         const { driver } = this.context;
-        const insert = driver.compiler.compileExpression(null, query);
-        return this.context.connection.executeQuery(insert, this.signal);
+        const selectQuery = driver.compiler.compileExpression(null, query);
+        const insertQuery = `INSERT INTO ${model.fullyQualifiedTableName}(${fields.join(",")})
+        ${selectQuery.text}`;
+        this.traceQuery?.(insertQuery);
+        return this.context.connection.executeQuery({
+            text: insertQuery,
+            values: selectQuery.values
+        }, this.signal);
     }
 
     selectView(parameters: any, fx: any): any {

package/src/query/ast/Expressions.ts

@@ -217,6 +217,8 @@ export class CallExpression extends Expression {
     readonly type = "CallExpression";
     callee: Expression;
     arguments: Expression[];
+    collectionMethod: string;
+    castMethod: string;
 }
 
 export class BracketExpression extends Expression {

package/src/query/parser/ArrowToExpression.ts

@@ -268,9 +268,12 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
 
         const method = name[2];
 
+        const castMethod = name[1] === "cast" ? name[2] : void 0;
+
         const reWrittenCe = CallExpression.create({
             callee: Expression.identifier(name.join(".")),
-            arguments: ce.arguments
+            arguments: ce.arguments,
+            castMethod
         });
 
 
@@ -290,6 +293,7 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
         }
 
         const left = CallExpression.create({
+            collectionMethod: method,
             callee: MemberExpression.create({
                 target: mapCallee.target,
                 property: Expression.identifier(method),

package/src/tests/db-tests/tests/insert-into.ts

@@ -0,0 +1,24 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext } from "../../model/createContext.js";
+import Sql from "../../../sql/Sql.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    await context.messages.asQuery()
+        .where(void 0, (p) => (x) => x.messageID > 100)
+        .select(void 0, (p) => (x) => ({
+            fromID: x.fromID,
+            toID: x.toID,
+            message: x.message
+        }))
+        .trace(console.log)
+        .insertInTo(context.archivedMessages);
+
+}

package/src/tests/model/ShoppingContext.ts

@@ -38,6 +38,10 @@ export class ShoppingContext extends EntityContext {
     public emailAddresses = this.model.register(EmailAddress);
 
     public userCategoryTags = this.model.register(UserCategoryTag);
+
+    public messages = this.model.register(UserMessage);
+
+    public archivedMessages = this.model.register(ArchivedUserMessage);
 }
 
 @Table("Users")
@@ -392,4 +396,36 @@ export class OrderItem {
     public product: Product;
     public productPrice: ProductPrice;
 
+}
+
+@Table("UserMessages")
+export class UserMessage {
+
+    @Column({ dataType: "BigInt", key: true, generated: "identity"})
+    messageID: number;
+
+    @Column({ dataType: "BigInt"})
+    fromID: number;
+
+    @Column({ dataType: "BigInt"})
+    toID: number;
+
+    @Column({ dataType: "Char"})
+    message: string;
+}
+
+@Table("ArchivedUserMessages")
+export class ArchivedUserMessage {
+
+    @Column({ dataType: "BigInt", key: true, generated: "identity"})
+    messageID: number;
+
+    @Column({ dataType: "BigInt"})
+    fromID: number;
+
+    @Column({ dataType: "BigInt"})
+    toID: number;
+
+    @Column({ dataType: "Char"})
+    message: string;
 }