@entity-access/entity-access 1.0.164 → 1.0.166

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/WorkflowContext.ts

@@ -129,6 +129,19 @@ export interface IWorkflowResult<T> {
     error: string;
 }
 
+export interface IWorkflowQueueParameter {
+    id?: string;
+    throwIfExists?: boolean;
+    eta?: DateTime;
+    parentID?: string;
+    taskGroup?: string;
+}
+
+export interface IWorkflowStartParams {
+    taskGroup?: string;
+    signal?: AbortSignal;
+}
+
 export default class WorkflowContext {
 
     private registry: Map<string, IWorkflowSchema> = new Map();
@@ -144,11 +157,11 @@ export default class WorkflowContext {
         this.registry.set(type.name, WorkflowRegistry.register(type, void 0));
     }
 
-    public async start({ workerGroup = "default", signal = void 0 as AbortSignal }) {
+    public async start({ taskGroup = "default", signal = void 0 as AbortSignal }: IWorkflowStartParams = {}) {
         console.log(`Started executing workflow jobs`);
         while(!signal?.aborted) {
             try {
-                const total = await this.processQueueOnce({ workerGroup, signal });
+                const total = await this.processQueueOnce({ taskGroup, signal });
                 if (total > 0) {
                     // do not wait till we have zero messages to process
                     continue;
@@ -177,12 +190,13 @@ export default class WorkflowContext {
     public async queue<T>(
         type: IClassOf<Workflow<T>>,
         input: T,
-        { id, throwIfExists, eta, parentID }: {
-            id?: string,
-            throwIfExists?: boolean,
-            eta?: DateTime,
-            parentID?: string
-        } = {}) {
+        {
+            id,
+            throwIfExists,
+            eta,
+            parentID,
+            taskGroup = "default"
+        }: IWorkflowQueueParameter = {}) {
         const clock = this.storage.clock;
         let tries = 1;
         if (id) {
@@ -215,6 +229,7 @@ export default class WorkflowContext {
                 eta ??= now;
                 await this.storage.save({
                     id,
+                    taskGroup,
                     name: schema.name,
                     input: JSON.stringify(input),
                     isWorkflow: true,
@@ -272,8 +287,8 @@ export default class WorkflowContext {
         // console.log(... a);
     }
 
-    public async processQueueOnce({ workerGroup = "default", signal = void 0 as AbortSignal } = {}) {
-        const pending = await this.storage.dequeue(workerGroup, signal);
+    public async processQueueOnce({ taskGroup = "default", signal = void 0 as AbortSignal } = {}) {
+        const pending = await this.storage.dequeue(taskGroup, signal);
         // run...
         for (const iterator of pending) {
             try {

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",
@@ -17,10 +19,10 @@ import RawQuery from "../compiler/RawQuery.js";
     filter: (x) => x.groupName !== null
 })
 @Index({
-    name: "IX_Workflows_WorkerGroup_ETA",
+    name: "IX_Workflows_taskGroup_ETA",
     columns: [
         { name: (x) => x.eta, descending: false },
-        { name: (x) => x.workerGroup, descending: false }
+        { name: (x) => x.taskGroup, descending: false }
     ],
     filter: (x) => x.isWorkflow === true
 })
@@ -57,7 +59,7 @@ export class WorkflowItem {
         dataType: "Char", length: 50,
         default: () => `default`
     })
-    public workerGroup: string;
+    public taskGroup: string;
 
     @Column({ dataType: "Int", default: () => 0})
     public priority: number;
@@ -124,7 +126,9 @@ export default class WorkflowStorage {
                 state: r.state,
                 output: r.output,
                 error: r.error,
-                lastID: r.lastID
+                lastID: r.lastID,
+                taskGroup: r.taskGroup,
+                [loadedFromDb]: true,
             };
         }
         return null;
@@ -146,7 +150,8 @@ export default class WorkflowStorage {
                 state: r.state,
                 output: r.output,
                 error: r.error,
-                lastID: r.lastID
+                lastID: r.lastID,
+                [loadedFromDb]: true
             };
         }
         return null;
@@ -185,26 +190,34 @@ 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);
-            }
-
-            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.workerGroup ||= "default";
-            w.updated ??= DateTime.utcNow;
-            await db.saveChanges();
         });
     }
 
-    async dequeue(workerGroup: string, signal?: AbortSignal) {
+    async dequeue(taskGroup: string, signal?: AbortSignal) {
         const db = new WorkflowContext(this.driver);
         const now = this.clock.utcNow;
 
@@ -250,11 +263,11 @@ export default class WorkflowStorage {
         const q = this.lockQuery;
 
         const items = await db.workflows
-            .where({now, workerGroup}, (p) => (x) => x.eta <= p.now
+            .where({now, taskGroup}, (p) => (x) => x.eta <= p.now
                 && (x.lockedTTL === null || x.lockedTTL <= p.now)
                 && x.lockToken === null
                 && x.isWorkflow === true
-                && x.workerGroup === p.workerGroup)
+                && x.taskGroup === p.taskGroup)
             .orderBy({}, (p) => (x) => x.eta)
             .thenBy({}, (p) => (x) => x.priority)
             .limit(20)

package/tsconfig.json

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