@entity-access/entity-access 1.0.165 → 1.0.167

package/src/decorators/Relate.ts

@@ -1,12 +1,15 @@
 import type { IClassOf } from "./IClassOf.js";
+import { IForeignKeyConstraint } from "./IForeignKeyConstraint.js";
 import SchemaRegistry from "./SchemaRegistry.js";
 import NameParser from "./parser/NameParser.js";
 
+
 export interface IRelatedType<T, TRelated> {
     property: (item: T) => TRelated;
     inverseProperty: (item: TRelated) => T[];
     inverseKey?: (item: TRelated) => any;
     dotNotCreateIndex?: boolean;
+    foreignKeyConstraint?: IForeignKeyConstraint;
 }
 
 export interface IRelatedTypeOne<T, TRelated> {
@@ -14,6 +17,7 @@ export interface IRelatedTypeOne<T, TRelated> {
     inverseProperty: (item: TRelated) => T;
     inverseKey?: (item: TRelated) => any;
     dotNotCreateIndex?: boolean;
+    foreignKeyConstraint?: IForeignKeyConstraint;
 }
 
 export interface IRelatedTypeWithType<T, TRelated> {
@@ -22,6 +26,7 @@ export interface IRelatedTypeWithType<T, TRelated> {
     inverseProperty: (item: TRelated) => T[];
     inverseKey?: (item: TRelated) => any;
     dotNotCreateIndex?: boolean;
+    foreignKeyConstraint?: IForeignKeyConstraint;
 }
 
 export interface IRelatedTypeOneWithType<T, TRelated> {
@@ -30,6 +35,7 @@ export interface IRelatedTypeOneWithType<T, TRelated> {
     inverseProperty: (item: TRelated) => T;
     inverseKey?: (item: TRelated) => any;
     dotNotCreateIndex?: boolean;
+    foreignKeyConstraint?: IForeignKeyConstraint;
 }
 export function RelateTo<T, TRelated>(p: IRelatedTypeWithType<T, TRelated>): (target: T, key: string) => any;
 export function RelateTo<T, TRelated>(c: IClassOf<TRelated>, p: IRelatedType<T, TRelated>): (target: T, key: string) => any;
@@ -43,7 +49,7 @@ export function RelateTo(c, p?): any {
         }
     }
 
-    const { property, inverseKey: invKey, inverseProperty, dotNotCreateIndex } = p;
+    const { property, inverseKey: invKey, inverseProperty, dotNotCreateIndex, foreignKeyConstraint } = p;
 
     return (target: any, foreignKey: string): any => {
 
@@ -60,6 +66,7 @@ export function RelateTo(c, p?): any {
             relatedTypeClassFactory: p.type,
             relatedName: NameParser.parseMember(inverseProperty),
             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
+            foreignKeyConstraint,
             dotNotCreateIndex
         });
 

package/src/drivers/base/BaseDriver.ts

@@ -7,7 +7,7 @@ import QueryCompiler from "../../compiler/QueryCompiler.js";
 import EntityType from "../../entity-query/EntityType.js";
 import Migrations from "../../migrations/Migrations.js";
 import ChangeEntry from "../../model/changes/ChangeEntry.js";
-import { BinaryExpression, Constant, DeleteStatement, ExistsExpression, Expression, Identifier, InsertStatement, NotExits, ReturnUpdated, SelectStatement, TableLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "../../query/ast/Expressions.js";
+import { BinaryExpression, Constant, DeleteStatement, ExistsExpression, Expression, Identifier, InsertStatement, NotExits, ReturnUpdated, SelectStatement, TableLiteral, UnionAllStatement, UpdateStatement, UpsertStatement, ValuesStatement } from "../../query/ast/Expressions.js";
 
 export interface IRecord {
     [key: string]: string | boolean | number | Date | Uint8Array | Blob;
@@ -148,6 +148,94 @@ export abstract class BaseDriver {
     /** Must dispose ObjectPools */
     abstract dispose();
 
+    createUpsertExpression(
+        type: EntityType,
+        entity: any,
+        mode: "update" | "upsert" | "insert",
+        entityKeys?: any): Expression {
+        const table = type.fullyQualifiedName as TableLiteral;
+
+        const returnFields = [] as Identifier[];
+        if (mode === "insert") {
+            const fields = [];
+            const values = [];
+            for (const iterator of type.columns) {
+                const value = entity[iterator.name];
+                if (value === void 0) {
+                    if (iterator.generated) {
+                        returnFields.push(Expression.identifier(iterator.columnName));
+                    }
+                    continue;
+                }
+                fields.push(Expression.identifier(iterator.columnName));
+                values.push(Expression.constant(value));
+            }
+            return InsertStatement.create({
+                table,
+                returnValues: returnFields.length ? ReturnUpdated.create({
+                    changes: "INSERTED",
+                    fields: returnFields
+                }) : void 0,
+                values: ValuesStatement.create({
+                    fields,
+                    values: [values]
+                })
+            });
+        }
+
+
+        const insert = [] as BinaryExpression[];
+        const update = [] as BinaryExpression[];
+        const keys = [] as BinaryExpression[];
+        for (const iterator of type.columns) {
+            const value = entity[iterator.name];
+            const assign = Expression.assign(
+                Expression.identifier(iterator.columnName),
+                Expression.constant(value)
+            );
+            if (entityKeys ? iterator.name in entityKeys : iterator.key) {
+                keys.push(assign);
+                insert.push(assign);
+                continue;
+            }
+            if (value === undefined) {
+                if (iterator.generated) {
+                    returnFields.push(Expression.identifier(iterator.columnName));
+                }
+                continue;
+            }
+            insert.push(assign);
+            if (value === undefined) {
+                continue;
+            }
+            update.push(assign);
+        }
+
+
+        if (mode === "update") {
+            let where = null;
+            for (const iterator of keys) {
+                where = where ? Expression.logicalAnd(where, iterator) : iterator;
+            }
+            return UpdateStatement.create({
+                table,
+                set: update,
+                where
+            });
+        }
+
+        return UpsertStatement.create({
+            table,
+            insert,
+            update,
+            keys,
+            returnUpdated: returnFields.length ? ReturnUpdated.create({
+                changes: "INSERTED",
+                fields: returnFields
+            }) : void 0
+        });
+    }
+
     createInsertExpression(type: EntityType, entity: any): InsertStatement {
         const returnFields = [] as Identifier[];
         const fields = [] as Identifier[];

package/src/drivers/sql-server/ExpressionToSqlServer.ts

@@ -1,6 +1,6 @@
 import ExpressionToSql from "../../query/ast/ExpressionToSql.js";
-import { BooleanLiteral, InsertStatement, NumberLiteral, OrderByExpression, ReturnUpdated, SelectStatement, ValuesStatement } from "../../query/ast/Expressions.js";
-import { ITextQuery, prepare } from "../../query/ast/IStringTransformer.js";
+import { BooleanLiteral, InsertStatement, NumberLiteral, OrderByExpression, ReturnUpdated, SelectStatement, UpsertStatement, ValuesStatement } from "../../query/ast/Expressions.js";
+import { ITextQuery, prepare, prepareJoin } from "../../query/ast/IStringTransformer.js";
 
 export default class ExpressionToSqlServer extends ExpressionToSql {
 
@@ -23,7 +23,7 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
     }
 
     visitInsertStatement(e: InsertStatement): ITextQuery {
-        const returnValues = this.visit(e.returnValues);
+        const returnValues = e.returnValues ? this.visit(e.returnValues) : [];
         if (e.values instanceof ValuesStatement) {
 
             const rows = [];
@@ -45,6 +45,82 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
 
     }
 
+    visitUpsertStatement(e: UpsertStatement): ITextQuery {
+        const table = this.visit(e.table);
+
+        const insertColumns = [];
+        const insertValues = [];
+        const updateSet = [];
+
+        const compare = [];
+
+        const keys = [];
+
+        for (const { left, right } of e.insert) {
+            const c = this.visit(left);
+            const v = this.visit(right);
+            insertColumns.push(c);
+            insertValues.push(v);
+        }
+
+        for (const { left, right } of e.update) {
+            const c = this.visit(left);
+            const v = this.visit(right);
+            updateSet.push(prepare `${c} = ${v}`);
+        }
+
+        for (const { left, right } of e.keys) {
+            const c = this.visit(left);
+            const v = this.visit(right);
+            compare.push(prepare `${c} = ${v}`);
+            keys.push(c);
+        }
+
+        const returnValues = e.returnUpdated ? this.visit(e.returnUpdated) : [];
+
+        if (!updateSet.length) {
+
+            if (e.returnUpdated) {
+
+                const fields = e.returnUpdated.fields.map((x) => this.visit(x));
+
+                return prepare `
+                    INSERT INTO ${table} (${prepareJoin(insertColumns)})
+                        ${returnValues}
+                    SELECT * FROM (VALUES (${prepareJoin(insertValues)})) as A(${prepareJoin(insertColumns)})
+                        WHERE NOT EXISTS (SELECT 1 FROM ${table} WHERE ${prepareJoin(compare, " AND ")});
+                    IF @@ROWCOUNT=0
+                    BEGIN
+                        SELECT ${prepareJoin(fields)} FROM ${table}
+                        WHERE ${prepareJoin(compare, " AND ")}
+                    END
+                `;
+            }
+            return prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
+            SELECT * FROM (VALUES (${prepareJoin(insertValues)})) as A(${prepareJoin(insertColumns)})
+            WHERE NOT EXISTS (SELECT 1 FROM ${table} WHERE ${prepareJoin(compare, " AND ")});
+            IF @@ROWCOUNT=0
+            BEGIN
+                SELECT ${prepareJoin(keys)} FROM ${table}
+                WHERE ${prepareJoin(compare, " AND ")}
+            END;`;
+    }
+
+        return prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
+            ${returnValues}
+            SELECT * FROM (VALUES (${prepareJoin(insertValues)})) as A(${prepareJoin(insertColumns)})
+            WHERE NOT EXISTS (SELECT 1 FROM ${table} WHERE ${prepareJoin(compare, " AND ")});
+            IF @@ROWCOUNT=0
+            BEGIN
+                UPDATE ${table}
+                SET
+                    ${prepareJoin(updateSet)}
+                WHERE ${prepareJoin(compare, " AND ")}
+                ${returnValues}
+            END;`;
+    }
+
+
     visitSelectStatement(e: SelectStatement): ITextQuery {
 
         this.prepareStatement(e);

package/src/drivers/sql-server/SqlServerDriver.ts

@@ -74,7 +74,12 @@ export class SqlServerConnection extends BaseConnection {
 
         try {
             const r = await rq.query(command.text);
-            return { rows: r.recordset ?? [r.output], updated: r.rowsAffected [0]};
+            let rows = r.recordset ?? [r.output];
+            if (rows.length === 0) {
+                // do something..
+                rows = r.recordsets[1];
+            }
+            return { rows, updated: r.rowsAffected [0]};
         } catch (error) {
             error = `Failed executing ${command.text}\r\n${error.stack ?? error}`;
             console.error(error);

package/src/entity-query/EntityType.ts

@@ -148,6 +148,15 @@ export default class EntityType {
         relatedType.relations.push(inverseRelation);
         inverseRelation.relatedRelation = relation;
         relation.relatedRelation = inverseRelation;
+
+        let { foreignKeyConstraint } = relation;
+        if(foreignKeyConstraint) {
+            foreignKeyConstraint = { ... foreignKeyConstraint};
+            relation.foreignKeyConstraint = foreignKeyConstraint;
+            foreignKeyConstraint.name ||= `FK_${this.name}_${fkColumn.name}_${this.typeClass.name}_${relatedType.keys[0].name}`;
+            foreignKeyConstraint.column = fkColumn;
+            foreignKeyConstraint.refColumns = relatedType.keys;
+        }
         return relation;
     }
 

package/src/migrations/Migrations.ts

@@ -1,7 +1,7 @@
 import { modelSymbol } from "../common/symbols/symbols.js";
 import type QueryCompiler from "../compiler/QueryCompiler.js";
-import { IIndex } from "../decorators/IIndex.js";
-import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import type { IForeignKeyConstraint } from "../decorators/IForeignKeyConstraint.js";
+import type { IIndex } from "../decorators/IIndex.js";
 import type EntityType from "../entity-query/EntityType.js";
 import type EntityContext from "../model/EntityContext.js";
 import type EntityQuery from "../model/EntityQuery.js";
@@ -37,6 +37,27 @@ export default abstract class Migrations {
             for (const index of type.indexes) {
                 await this.migrateIndexInternal(context, index, type);
             }
+
+            for (const { isInverseRelation , foreignKeyConstraint, relatedTypeClass } of type.relations) {
+                if (isInverseRelation) {
+                    continue;
+                }
+                if (!foreignKeyConstraint) {
+                    continue;
+                }
+
+                const relatedEntity = model.register(relatedTypeClass)[modelSymbol] as EntityType;
+
+                foreignKeyConstraint.type = type;
+                foreignKeyConstraint.column = type.getProperty(foreignKeyConstraint.column.name).field;
+                const refColumns = foreignKeyConstraint.refColumns;
+                foreignKeyConstraint.refColumns = [];
+                for (const iterator of refColumns) {
+                    foreignKeyConstraint.refColumns.push(relatedEntity.getProperty(iterator.name).field);
+                }
+
+                await this.migrateForeignKey(context, foreignKeyConstraint);
+            }
         }
 
     }
@@ -69,5 +90,7 @@ export default abstract class Migrations {
 
     abstract migrateTable(context: EntityContext, type: EntityType): Promise<any>;
 
+    abstract migrateForeignKey(context: EntityContext, constraint: IForeignKeyConstraint);
+
 
 }

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -1,4 +1,5 @@
 import { IColumn } from "../../decorators/IColumn.js";
+import { IForeignKeyConstraint } from "../../decorators/IForeignKeyConstraint.js";
 import { IIndex } from "../../decorators/IIndex.js";
 import { BaseConnection, BaseDriver } from "../../drivers/base/BaseDriver.js";
 import EntityType from "../../entity-query/EntityType.js";
@@ -129,5 +130,54 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
         await driver.executeQuery(query);
     }
 
+    async migrateForeignKey(context: EntityContext, constraint: IForeignKeyConstraint) {
+        const { type } = constraint;
+        const name = type.schema
+        ? type.schema + "." + type.name
+        : type.name;
+
+        let text = `select constraint_name 
+        from information_schema.constraint_column_usage 
+        where table_name = $1 and constraint_name = $2 `;
+
+        const values = [type.name, constraint.name];
+
+        if(type.schema) {
+            text += " and schema_name = $3";
+            values.push(type.schema);
+        }
+
+        const driver = context.connection;
+
+        const r = await driver.executeQuery({ text, values });
+        if (r.rows?.length) {
+            return;
+        }
+
+        text = `ALTER TABLE ${name} ADD CONSTRAINT ${constraint.name} 
+            foreign key (${constraint.column.columnName})
+            references ${constraint.refColumns[0].entityType.name}(
+                ${constraint.refColumns.map((x) => x.columnName).join(",")}
+            ) `;
+
+        switch(constraint.cascade) {
+            case "delete":
+                text += " ON DELETE CASCADE";
+                break;
+            case "set-null":
+                text += " ON DELETE SET NULL";
+                break;
+            case "set-default":
+                text += " ON DELETE SET DEFAULT";
+                break;
+            case "restrict":
+                text += " ON DELETE RESTRICT";
+                break;
+        }
+
+        await driver.executeQuery(text);
+
+    }
+
 
 }

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

@@ -1,4 +1,5 @@
 import { IColumn } from "../../decorators/IColumn.js";
+import { IForeignKeyConstraint } from "../../decorators/IForeignKeyConstraint.js";
 import { IIndex } from "../../decorators/IIndex.js";
 import { BaseConnection, BaseDriver } from "../../drivers/base/BaseDriver.js";
 import { SqlServerLiteral } from "../../drivers/sql-server/SqlServerLiteral.js";
@@ -136,5 +137,51 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         await driver.executeQuery(query);
     }
 
+    async migrateForeignKey(context: EntityContext, constraint: IForeignKeyConstraint) {
+        const { type } = constraint;
+        const name = type.schema
+        ? type.schema + "." + type.name
+        : type.name;
+
+        let text = `SELECT COUNT(*) 
+        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS 
+        WHERE TABLE_NAME='${type.name}' 
+        AND CONSTRAINT_NAME='${constraint.name}' 
+        AND CONSTRAINT_TYPE='FOREIGN KEY'`;
+
+        if(type.schema) {
+            text += ` and schema_name = ${type.schema}`;
+        }
+
+        const driver = context.connection;
+
+        const r = await driver.executeQuery(text);
+        if (r.rows?.length) {
+            return;
+        }
+
+        text = `ALTER TABLE ${name} ADD CONSTRAINT ${constraint.name} 
+            foreign key (${constraint.column.columnName})
+            references ${constraint.refColumns[0].entityType.name}(
+                ${constraint.refColumns.map((x) => x.columnName).join(",")}
+            ) `;
+
+        switch(constraint.cascade) {
+            case "delete":
+                text += " ON DELETE CASCADE";
+                break;
+            case "set-null":
+                text += " ON DELETE SET NULL";
+                break;
+            case "set-default":
+                text += " ON DELETE SET DEFAULT";
+                break;
+            case "restrict":
+                text += " ON DELETE RESTRICT";
+                break;
+        }
+
+        await driver.executeQuery(text);
+    }
 
 }

package/src/model/EntitySource.ts

@@ -1,12 +1,16 @@
 import type EntityContext from "./EntityContext.js";
 import type EntityType from "../entity-query/EntityType.js";
 import type { IEntityQuery, IFilterExpression } from "./IFilterWithParameter.js";
-import { Expression } from "../query/ast/Expressions.js";
 import EntityQuery from "./EntityQuery.js";
 import { contextSymbol, modelSymbol } from "../common/symbols/symbols.js";
+import { Expression } from "../query/ast/Expressions.js";
 
 export class EntitySource<T = any> {
 
+    public statements = {
+
+    };
+
     get [modelSymbol]() {
         return this.model;
     }
@@ -17,6 +21,7 @@ export class EntitySource<T = any> {
 
     private filter: Expression;
 
+
     constructor(
         private readonly model: EntityType,
         private readonly context: EntityContext
@@ -24,6 +29,24 @@ export class EntitySource<T = any> {
 
     }
 
+    public async saveDirect(item: Partial<T>, mode: "update" | "upsert" | "insert", keys?: Partial<T>) {
+        const { driver } = this.context;
+        const expression = driver.createUpsertExpression(this.model, item, mode, keys);
+        const { text, values } = driver.compiler.compileExpression(null, expression);
+        const r = await this.context.connection.executeQuery({ text, values });
+        if(r.rows?.length) {
+            const first = r.rows[0];
+            for (const key in first) {
+                if (Object.prototype.hasOwnProperty.call(first, key)) {
+                    const element = first[key];
+                    const name = this.model.getColumn(key).name;
+                    item[name] = element;
+                }
+            }
+        }
+        return item;
+    }
+
     public add(item: Partial<T>): T {
         const p = Object.getPrototypeOf(item).constructor;
         if (!p || p === Object) {

package/src/query/ast/ExpressionToSql.ts

@@ -3,7 +3,7 @@ import EntityType, { IEntityProperty } from "../../entity-query/EntityType.js";
 import EntityQuery from "../../model/EntityQuery.js";
 import { FilteredExpression, filteredSymbol } from "../../model/events/FilteredExpression.js";
 import { NotSupportedError } from "../parser/NotSupportedError.js";
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, UpsertStatement, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import { ITextQuery, QueryParameter, prepare, prepareJoin } from "./IStringTransformer.js";
 import ParameterScope from "./ParameterScope.js";
 import Visitor from "./Visitor.js";
@@ -457,7 +457,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
     }
 
     visitInsertStatement(e: InsertStatement): ITextQuery {
-        const returnValues = this.visit(e.returnValues);
+        const returnValues = e.returnValues ? this.visit(e.returnValues) : [];
         if (e.values instanceof ValuesStatement) {
 
             const rows = [];
@@ -490,6 +490,71 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         return prepare `UPDATE ${table} SET ${set} WHERE ${where}`;
     }
 
+    visitUpsertStatement(e: UpsertStatement): ITextQuery {
+        const table = this.visit(e.table);
+
+        const insertColumns = [];
+        const insertValues = [];
+        const updateSet = [];
+
+        const compare = [];
+        const compareKeys = [];
+
+        for (const { left, right } of e.insert) {
+            const c = this.visit(left);
+            const v = this.visit(right);
+            insertColumns.push(c);
+            insertValues.push(v);
+        }
+
+        for (const { left, right } of e.update) {
+            const c = this.visit(left);
+            const v = this.visit(right);
+            updateSet.push(prepare `${c} = ${v}`);
+        }
+
+        for (const { left, right } of e.keys) {
+            const c = this.visit(left);
+            const v = this.visit(right);
+            compare.push(prepare `${c}=${v}`);
+            compareKeys.push(c);
+        }
+
+        const returnValues = e.returnUpdated ? this.visit(e.returnUpdated) : [];
+
+        if (!updateSet.length) {
+
+            if (e.returnUpdated) {
+
+                const keys = e.returnUpdated.fields.map((x) => this.visit(x));
+
+                return prepare `WITH x AS(
+                    INSERT INTO ${table} (${prepareJoin(insertColumns)})
+                        VALUES (${prepareJoin(insertValues)})
+                        ON CONFLICT(${prepareJoin(compareKeys)})
+                        DO NOTHING
+                    ${returnValues}
+                )
+                SELECT * FROM x
+                UNION
+                    SELECT ${prepareJoin(keys)} FROM ${table} WHERE ${prepareJoin(compare, " AND ")}`;
+            }
+
+            return prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
+            VALUES (${prepareJoin(insertValues)})
+            ON CONFLICT(${prepareJoin(compareKeys)})
+            DO NOTHING
+            ${returnValues}`;
+        }
+
+        return prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
+            VALUES (${prepareJoin(insertValues)})
+            ON CONFLICT(${prepareJoin(compareKeys)})
+            DO UPDATE SET
+                ${prepareJoin(updateSet)}
+            ${returnValues}`;
+    }
+
     visitNewObjectExpression(e: NewObjectExpression): ITextQuery {
         return prepare `FROM (${this.visitArray(e.properties)})`;
     }

package/src/query/ast/Expressions.ts

@@ -392,6 +392,15 @@ export class UpdateStatement extends Expression {
 
 }
 
+export class UpsertStatement extends Expression {
+    readonly type = "UpsertStatement";
+    table: TableLiteral | Identifier;
+    insert: BinaryExpression[];
+    update: BinaryExpression[];
+    keys: BinaryExpression[];
+    returnUpdated: ReturnUpdated;
+}
+
 export class UnionAllStatement extends Expression {
     readonly type = "UnionAllStatement";
     queries: Expression[];
@@ -399,7 +408,7 @@ export class UnionAllStatement extends Expression {
 
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
-    table: TableLiteral | Identifier
+    table: TableLiteral | Identifier;
     where: Expression;
 }
 
@@ -414,6 +423,7 @@ export type ExpressionType =
     InsertStatement|
     UpdateStatement|
     DeleteStatement|
+    UpsertStatement|
     ReturnUpdated|
     OrderByExpression|
     JoinExpression|

package/src/query/ast/Visitor.ts

@@ -1,5 +1,5 @@
 import { NotSupportedError } from "../parser/NotSupportedError.js";
-import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, UpsertStatement, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 
 
 export default abstract class Visitor<T = any> {
@@ -71,10 +71,15 @@ export default abstract class Visitor<T = any> {
                 return this.visitNotExists(e);
             case "UnionAllStatement":
                 return this.visitUnionAllStatement(e);
+            case "UpsertStatement":
+                return this.visitUpsertStatement(e);
         }
         const c: never = e;
         throw new Error(`${e1.type} Not implemented`);
     }
+    visitUpsertStatement(e: UpsertStatement): T {
+        throw new Error("Method not implemented.");
+    }
     visitUnionAllStatement(e: UnionAllStatement): T {
         throw new NotSupportedError("Union All");
     }

package/src/tests/db-tests/tests/upsert-test.ts

@@ -0,0 +1,18 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    let e = await context.emailAddresses.saveDirect({ address: "e@e.com"}, "upsert", { address: "e@e.com"});
+    assert.strictEqual("1", e.id);
+    e = await context.emailAddresses.saveDirect({ address: "e@e.com"}, "upsert", { address: "e@e.com"});
+    assert.strictEqual("1", e.id);
+    await context.saveChanges();
+}