@entity-access/entity-access 1.0.169 → 1.0.171

package/src/model/EntitySource.ts

@@ -3,7 +3,7 @@ import type EntityType from "../entity-query/EntityType.js";
 import type { IEntityQuery, IFilterExpression } from "./IFilterWithParameter.js";
 import EntityQuery from "./EntityQuery.js";
 import { contextSymbol, modelSymbol } from "../common/symbols/symbols.js";
-import { Expression } from "../query/ast/Expressions.js";
+import { Expression, Identifier } from "../query/ast/Expressions.js";
 import { DirectSaveType } from "../drivers/base/BaseDriver.js";
 
 export class EntitySource<T = any> {
@@ -30,9 +30,66 @@ export class EntitySource<T = any> {
 
     }
 
-    public async saveDirect(item: Partial<T>, mode: DirectSaveType, keys?: Partial<T>) {
+    public async saveDirect({
+        test,
+        mode,
+        changes,
+        select
+    }: { test?: Partial<T>, changes: Partial<T>, select?: Partial<T>, mode: DirectSaveType }) {
+
         const { driver } = this.context;
-        const expression = driver.createUpsertExpression(this.model, item, mode, keys);
+
+        const returnFields = [] as Identifier[];
+
+        if (!select) {
+            for (const iterator of this.model.columns) {
+                if(iterator.generated || iterator.key) {
+                    returnFields.push(Expression.identifier(iterator.columnName));
+                }
+            }
+        } else {
+            for (const key in select) {
+                if (Object.prototype.hasOwnProperty.call(select, key)) {
+                    const field = this.model.getField(key);
+                    if (field) {
+                        returnFields.push(Expression.identifier(field.columnName));
+                    }
+                }
+            }
+        }
+
+        if (mode === "insert-select" || mode === "upsert") {
+            // check if it exits..
+            if (!test) {
+                test = {};
+                for (const iterator of this.model.keys) {
+                    test[iterator.name] = changes[iterator.name];
+                }
+            }
+            const exists = driver.createSelectWithKeysExpression(this.model, test, returnFields);
+            const q = driver.compiler.compileExpression(null, exists);
+            const er = await this.context.connection.executeQuery(q);
+            if (er.rows?.[0]) {
+                const fr = er.rows[0];
+                for (const key in fr) {
+                    if (Object.prototype.hasOwnProperty.call(fr, key)) {
+                        const element = fr[key];
+                        const name = this.model.getColumn(key).name;
+                        changes[name] = element;
+                    }
+                }
+
+                if (mode !== "upsert") {
+                    return changes;
+                }
+                mode = "update";
+            }
+        }
+
+        const expression = driver.createUpsertExpression(this.model, changes, mode, test, returnFields);
+        if (!expression) {
+            return changes;
+        }
         const { text, values } = driver.compiler.compileExpression(null, expression);
         const r = await this.context.connection.executeQuery({ text, values });
         if(r.rows?.length) {
@@ -41,11 +98,11 @@ export class EntitySource<T = any> {
                 if (Object.prototype.hasOwnProperty.call(first, key)) {
                     const element = first[key];
                     const name = this.model.getColumn(key).name;
-                    item[name] = element;
+                    changes[name] = element;
                 }
             }
         }
-        return item;
+        return changes;
     }
 
     public add(item: Partial<T>): T {

package/src/query/ast/ExpressionToSql.ts

@@ -531,7 +531,6 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 return prepare `WITH x AS(
                     INSERT INTO ${table} (${prepareJoin(insertColumns)})
                         VALUES (${prepareJoin(insertValues)})
-                        LIMIT COALESCE((SELECT 1 FROM ${table} WHERE ${prepareJoin(compare, " AND ")}),2)-1
                         ON CONFLICT(${prepareJoin(compareKeys)})
                         DO NOTHING
                     ${returnValues}
@@ -543,38 +542,41 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
             return prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
             VALUES (${prepareJoin(insertValues)})
-            LIMIT COALESCE((SELECT 1 FROM ${table} WHERE ${prepareJoin(compare, " AND ")}),2)-1
             ON CONFLICT(${prepareJoin(compareKeys)})
             DO NOTHING`;
         }
 
-        const r = prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
-            VALUES (${prepareJoin(insertValues)})
-            ON CONFLICT(${prepareJoin(compareKeys)})
-            DO UPDATE SET
-                ${prepareJoin(updateSet)}
-            ${returnValues}`;
-
-        return r;
-
-        // return prepare `
-        // WITH U1 AS(
-        //         UPDATE ${table} SET
-        //             ${prepareJoin(updateSet)}
-        //         WHERE ${prepareJoin(compare, " AND ")}
-        //     ),
-        //     I1 AS(
-        //         INSERT INTO ${table} (${prepareJoin(insertColumns)})
-        //         VALUES (${prepareJoin(insertValues)})
-        //         LIMIT COALESCE((SELECT 1 FROM ${table} WHERE ${prepareJoin(compare, " AND ")}),2)-1
-        //         ON CONFLICT(${prepareJoin(compareKeys)})
-        //         DO UPDATE SET
-        //             ${prepareJoin(updateSet)}
-        //         ${returnValues}
-        //     )
-        // SELECT * from U1
-        // UNION
-        // SELECT * from I1`;
+        // const r = prepare `INSERT INTO ${table} (${prepareJoin(insertColumns)})
+        //     VALUES (${prepareJoin(insertValues)})
+        //     ON CONFLICT(${prepareJoin(compareKeys)})
+        //     DO UPDATE SET
+        //         ${prepareJoin(updateSet)}
+        //     ${returnValues}`;
+
+        // return r;
+
+        if (returnValues.length === 0) {
+            returnValues.push([" RETURNING * "]);
+        }
+
+        return prepare `
+        WITH U1 AS(
+                UPDATE ${table} SET
+                    ${prepareJoin(updateSet)}
+                WHERE ${prepareJoin(compare, " AND ")}
+                ${returnValues}
+            ),
+            I1 AS(
+                INSERT INTO ${table} (${prepareJoin(insertColumns)})
+                VALUES (${prepareJoin(insertValues)})
+                ON CONFLICT(${prepareJoin(compareKeys)})
+                DO UPDATE SET
+                    ${prepareJoin(updateSet)}
+                ${returnValues}
+            )
+        SELECT * from U1
+        UNION
+        SELECT * from I1`;
     }
 
     visitNewObjectExpression(e: NewObjectExpression): ITextQuery {

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

@@ -10,15 +10,20 @@ export default async function(this: TestConfig) {
 
     const context = await createContext(this.driver);
 
-    let e = await context.emailAddresses.saveDirect({ address: "e@e.com"}, "upsert", { address: "e@e.com"});
+    let changes = { address: "e@e.com"};
+    let test = { ... changes };
+
+    let e = await context.emailAddresses.saveDirect({ mode: "upsert", changes, test});
     assert.strictEqual("1", e.id);
-    e = await context.emailAddresses.saveDirect({ address: "e@e.com"}, "upsert", { address: "e@e.com"});
+    e = await context.emailAddresses.saveDirect({ mode: "upsert", changes, test});
     assert.strictEqual("1", e.id);
 
-    e = await context.emailAddresses.saveDirect({ address: "a@e.com"}, "insert-select", { address: "a@e.com"});
+    changes = { address: "a@e.com"};
+    test = { ... changes };
+    e = await context.emailAddresses.saveDirect({ mode: "insert-select", changes, test});
     assert.strictEqual("2", e.id);
 
-    e = await context.emailAddresses.saveDirect({ address: "a@e.com"}, "insert-select", { address: "a@e.com"});
+    e = await context.emailAddresses.saveDirect({ mode: "insert-select", changes, test});
     assert.strictEqual("2", e.id);
 
     await context.saveChanges();

package/src/workflows/WorkflowStorage.ts

@@ -210,9 +210,9 @@ export default class WorkflowStorage {
             state.taskGroup ||= "default";
             // await db.saveChanges();
             if(state[loadedFromDb]) {
-                await db.workflows.saveDirect(state, "update");
+                await db.workflows.saveDirect({ mode: "update", changes: state });
             } else {
-                await db.workflows.saveDirect(state, "upsert");
+                await db.workflows.saveDirect({ mode: "upsert", changes: state });
             }
         });
     }