@entity-access/entity-access 1.0.165 → 1.0.166

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,75 @@ export abstract class BaseDriver {
     /** Must dispose ObjectPools */
     abstract dispose();
 
+    createUpsertExpression(type: EntityType, entity: any, mode: "update" | "upsert" | "insert"): Expression {
+        const table = type.fullyQualifiedName as TableLiteral;
+
+        if (mode === "insert") {
+            const fields = [];
+            const values = [];
+            for (const iterator of type.columns) {
+                const value = entity[iterator.name];
+                if (value === void 0) {
+                    continue;
+                }
+                fields.push(Expression.identifier(iterator.columnName));
+                values.push(Expression.constant(value));
+            }
+            return InsertStatement.create({
+                table,
+                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 (iterator.key) {
+                keys.push(assign);
+                insert.push(assign);
+                continue;
+            }
+            if (value === undefined) {
+                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
+        });
+    }
+
     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,48 @@ export default class ExpressionToSqlServer extends ExpressionToSql {
 
     }
 
+    visitUpsertStatement(e: UpsertStatement): ITextQuery {
+        const table = this.visit(e.table);
+
+        const insertColumns = [];
+        const insertValues = [];
+        const updateSet = [];
+
+        const compare = [];
+
+        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}`);
+        }
+
+
+        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
+                UPDATE ${table}
+                SET
+                    ${prepareJoin(updateSet)}
+                WHERE ${prepareJoin(compare, " AND ")}
+            END;`;
+    }
+
+
     visitSelectStatement(e: SelectStatement): ITextQuery {
 
         this.prepareStatement(e);

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,13 @@ export class EntitySource<T = any> {
 
     }
 
+    public async saveDirect(item: Partial<T>, mode: "update" | "upsert" | "insert") {
+        const { driver } = this.context;
+        const expression = driver.createUpsertExpression(this.model, item, mode);
+        const { text, values } = driver.compiler.compileExpression(null, expression);
+        await this.context.connection.executeQuery({ text, values });
+    }
+
     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,41 @@ 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 = [];
+
+        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);
+            compare.push(c);
+        }
+
+
+        return prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
+            VALUES (${prepareJoin(insertValues)})
+            ON CONFLICT(${prepareJoin(compare)})
+            DO UPDATE SET
+                ${prepareJoin(updateSet)} `;
+    }
+
     visitNewObjectExpression(e: NewObjectExpression): ITextQuery {
         return prepare `FROM (${this.visitArray(e.properties)})`;
     }

package/src/query/ast/Expressions.ts

@@ -392,6 +392,14 @@ export class UpdateStatement extends Expression {
 
 }
 
+export class UpsertStatement extends Expression {
+    readonly type = "UpsertStatement";
+    table: TableLiteral | Identifier;
+    insert: BinaryExpression[];
+    update: BinaryExpression[];
+    keys: BinaryExpression[];
+}
+
 export class UnionAllStatement extends Expression {
     readonly type = "UnionAllStatement";
     queries: Expression[];
@@ -399,7 +407,7 @@ export class UnionAllStatement extends Expression {
 
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
-    table: TableLiteral | Identifier
+    table: TableLiteral | Identifier;
     where: Expression;
 }
 
@@ -414,6 +422,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/model/ShoppingContext.ts

@@ -297,7 +297,10 @@ export class OrderItem {
     @RelateTo({
         type: () => Order,
         property: (orderItem) => orderItem.order,
-        inverseProperty: (order) => order.orderItems
+        inverseProperty: (order) => order.orderItems,
+        foreignKeyConstraint: {
+            cascade: "delete"
+        }
     })
     public orderID: number;
 

package/src/workflows/WorkflowStorage.ts

@@ -10,6 +10,8 @@ import DateTime from "../types/DateTime.js";
 import WorkflowClock from "./WorkflowClock.js";
 import RawQuery from "../compiler/RawQuery.js";
 
+const loadedFromDb = Symbol("loadedFromDB");
+
 @Table("Workflows")
 @Index({
     name: "IX_Workflows_Group",
@@ -126,6 +128,7 @@ export default class WorkflowStorage {
                 error: r.error,
                 lastID: r.lastID,
                 taskGroup: r.taskGroup,
+                [loadedFromDb]: true,
             };
         }
         return null;
@@ -148,7 +151,7 @@ export default class WorkflowStorage {
                 output: r.output,
                 error: r.error,
                 lastID: r.lastID,
-                taskGroup: r.taskGroup
+                [loadedFromDb]: true
             };
         }
         return null;
@@ -187,22 +190,30 @@ export default class WorkflowStorage {
         const db = new WorkflowContext(this.driver);
         const connection = db.connection;
         await connection.runInTransaction(async () => {
-            let w = await db.workflows.where(state, (p) => (x) => x.id === p.id).first();
-            if (!w) {
-                w = db.workflows.add(state);
-                w.taskGroup ||= "default";
-            }
-
-            for (const key in state) {
-                if (Object.prototype.hasOwnProperty.call(state, key)) {
-                    const element = state[key];
-                    w[key] = element;
-                }
+            // let w = await db.workflows.where(state, (p) => (x) => x.id === p.id).first();
+            // if (!w) {
+            //     w = db.workflows.add(state);
+            //     w.taskGroup ||= "default";
+            // }
+
+            // for (const key in state) {
+            //     if (Object.prototype.hasOwnProperty.call(state, key)) {
+            //         const element = state[key];
+            //         w[key] = element;
+            //     }
+            // }
+
+            // w.state ||= "queued";
+            // w.updated ??= DateTime.utcNow;
+            state.state ||= "queued";
+            state.updated ??= DateTime.utcNow;
+            state.taskGroup ||= "default";
+            // await db.saveChanges();
+            if(state[loadedFromDb]) {
+                await db.workflows.saveDirect(state, "update");
+            } else {
+                await db.workflows.saveDirect(state, "upsert");
             }
-
-            w.state ||= "queued";
-            w.updated ??= DateTime.utcNow;
-            await db.saveChanges();
         });
     }
 

package/tsconfig.json

@@ -13,7 +13,7 @@
         "emitDecoratorMetadata": true,
         "lib": [
             "ES2018",
-            "esnext.disposable"
+            "ESNext.Disposable"
         ]
     },
     "include": [