@entity-access/entity-access 1.0.323 → 1.0.325

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

@@ -32,14 +32,15 @@ export default class SqlServerDriver extends BaseDriver {
         const values = [];
         let returning = "";
         let i = 1;
+        const { quote } = this.compiler;
         for (const iterator of type.columns) {
             if (iterator.generated || iterator.computed) {
                 if (returning) {
-                    returning += ",";
+                    returning += ",\r\n\t\t";
                 } else {
                     returning = "OUTPUT ";
                 }
-                returning += "INSERTED." + iterator.columnName + " as " + this.compiler.quote(iterator.name);
+                returning += "INSERTED." + iterator.columnName + " as " + quote(iterator.name);
                 continue;
             }
             const field = iterator.columnName;
@@ -49,8 +50,8 @@ export default class SqlServerDriver extends BaseDriver {
             }
             values.push(value);
             if (fields) {
-                fields += ",";
-                valueParams += ",";
+                fields += ",\r\n\t\t";
+                valueParams += ",\r\n\t\t";
             }
             fields += field;
             valueParams += `$${i++}`;

package/src/model/EntitySource.ts

@@ -65,40 +65,69 @@ export class EntityStatements<T = any> {
         this.context = source[contextSymbol];
     }
 
-    async select(keys: Partial<T>, loadChangeEntry = false): Promise<T> {
-        const q = this.context.driver.selectQueryWithKeys(this.model, keys);
+    async select(entity: Partial<T>, loadChangeEntry = false): Promise<T> {
+        const q = this.context.driver.selectQueryWithKeys(this.model, entity);
         const r = await this.context.connection.executeQuery(q);
         const result = r.rows[0];
+        if (result) {
+            for (const key in result) {
+                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                    const element = result[key];
+                    entity[key] = element;
+                }
+            }
+        }
         if (loadChangeEntry) {
-            const ce = this.context.changeSet.getEntry(result);
-            ce.apply(result);
-            return ce.entity;
+            const ce = this.context.changeSet.getEntry(entity, entity);
+            return ce.entity as T;
         }
-        return result;
+        return entity as T;
     }
 
     async insert(entity: Partial<T>, loadChangeEntry = false): Promise<T> {
         const q = this.context.driver.insertQuery(this.model, entity);
+        // console.log(q.text);
         const r = await this.context.connection.executeQuery(q);
         const result = r.rows[0];
+        if (result) {
+            for (const key in result) {
+                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                    const element = result[key];
+                    entity[key] = element;
+                }
+            }
+        }
         if (loadChangeEntry) {
-            const ce = this.context.changeSet.getEntry(result);
-            ce.apply(result);
-            return ce.entity;
+            const ce = this.context.changeSet.getEntry(entity, entity);
+            return ce.entity as any;
         }
-        return r.rows[0];
+        return entity as any;
     }
 
     async update(entity: Partial<T>, loadChangeEntry = false): Promise<T> {
-        const q = this.context.driver.updateQuery(this.model, entity);
-        const r = await this.context.connection.executeQuery(q);
-        const result = r.rows?.[0];
+        const { context } = this;
+        const { driver } = context;
+        const q = driver.updateQuery(this.model, entity);
+        // console.log(q.text);
+        const r = await context.connection.executeQuery(q);
+        if (!r.updated) {
+            return void 0;
+        }
+        const result = r.rows[0];
+        if (result) {
+            for (const key in result) {
+                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                    const element = result[key];
+                    entity[key] = element;
+                }
+            }
+        }
         if (loadChangeEntry) {
-            const ce = this.context.changeSet.getEntry(result);
-            ce.apply(result ?? {});
-            return ce.entity;
+            const ce = this.context.changeSet.getEntry(entity);
+            ce.apply(entity ?? {});
+            return ce.entity as any;
         }
-        return r.rows[0];
+        return entity as any;
     }
 
     async selectOrInsert(entity: Partial<T>, retry = 3): Promise<T> {
@@ -128,7 +157,7 @@ export class EntityStatements<T = any> {
         }
     }
 
-    async upsert(entity: Partial<T>, updateAfterSelect: (x:T) => T, retry = 3): Promise<T> {
+    async upsert(entity: Partial<T>, updateAfterSelect?: (x:T) => T, retry = 3): Promise<T> {
 
         const tx = this.context.connection.currentTransaction;
         let tid: string;
@@ -142,13 +171,11 @@ export class EntityStatements<T = any> {
                 let existing = await this.select(entity) as T;
                 if (existing) {
                     existing = updateAfterSelect(existing);
-                    for (const key in entity) {
-                        if (Object.prototype.hasOwnProperty.call(entity, key)) {
-                            const element = entity[key];
-                            existing[key] = element;
+                    for (const key in existing) {
+                        if (Object.prototype.hasOwnProperty.call(existing, key)) {
+                            entity[key] = existing[key];
                         }
                     }
-                    entity = existing;
                 }
             }
             const r = await this.update(entity);

package/src/workflows/WorkflowStorage.ts

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