@entity-access/entity-access 1.0.319 → 1.0.321

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

@@ -7,6 +7,7 @@ import SqlServerQueryCompiler from "./SqlServerQueryCompiler.js";
 import SqlServerAutomaticMigrations from "../../migrations/sql-server/SqlServerAutomaticMigrations.js";
 import { SqlServerLiteral } from "./SqlServerLiteral.js";
 import TimedCache from "../../common/cache/TimedCache.js";
+import EntityType from "../../entity-query/EntityType.js";
 
 export type ISqlServerConnectionString = IDbConnectionString & sql.config;
 
@@ -25,6 +26,39 @@ export default class SqlServerDriver extends BaseDriver {
         config.server = config.host;
     }
 
+    insertQuery(type: EntityType, entity: any): { text: string; values: any[]; } {
+        let fields = "";
+        let valueParams = "";
+        const values = [];
+        let returning = "";
+        let i = 1;
+        for (const iterator of type.columns) {
+            if (iterator.generated || iterator.computed) {
+                if (returning) {
+                    returning += ",";
+                } else {
+                    returning = "OUTPUT ";
+                }
+                returning += "INSERTED." + iterator.columnName + " as " + this.compiler.quote(iterator.name);
+                continue;
+            }
+            const field = iterator.columnName;
+            const value = entity[iterator.name];
+            if (value === void 0) {
+                continue;
+            }
+            values.push(value);
+            if (fields) {
+                fields += ",";
+                valueParams += ",";
+            }
+            fields += field;
+            valueParams += `$${i++}`;
+        }
+        const text = `INSERT INTO ${type.fullyQualifiedTableName}(${fields}) ${returning} VALUES (${valueParams})`;
+        return { text, values };
+    }
+
     dispose() {
         // do nothing
     }

package/src/entity-query/EntityType.ts

@@ -40,6 +40,7 @@ export default class EntityType {
     public readonly keys: IColumn[] = [];
 
     public readonly nonKeys: IColumn[] = [];
+    public readonly fullyQualifiedTableName: string;
 
     @InstanceCache
     public get fullyQualifiedName() {
@@ -67,6 +68,7 @@ export default class EntityType {
         this.schema = original.schema ? (namingConvention ? namingConvention(original.schema) : original.schema) : original.schema;
         this.entityName = original.entityName;
         this.doNotCreate = original.doNotCreate;
+        this.fullyQualifiedTableName = this.schema ? `${this.schema}.${this.name}` : this.name;
     }
 
     [addOrCreateColumnSymbol](name: string): IColumn {

package/src/model/EntityContext.ts

@@ -230,7 +230,9 @@ export default class EntityContext {
     }
 
     private async saveChangesInternalWithoutEvents(options?: ISaveOptions) {
+        const signal = options?.signal;
         const copy = Array.from(this.changeSet.getChanges()) as ChangeEntry[];
+        const { connection } = this;
         for (const iterator of copy) {
             switch (iterator.status) {
                 case "inserted":
@@ -238,23 +240,26 @@ export default class EntityContext {
                     // we are choosing not to create one complicated SQL as generation
                     // of insert requires checking if value is supplied or not, if not, we have to choose
                     // default value
-                    const insert = this.driver.createInsertExpression(iterator.type, iterator.entity);
-                    const r = await this.executeExpression(insert, options);
-                    iterator.apply(r);
+                    // const insert = this.driver.createInsertExpression(iterator.type, iterator.entity);
+                    // const r = await this.executeExpression(insert, options);
+                    const insert = this.driver.insertQuery(iterator.type, iterator.entity);
+                    const r = await connection.executeQuery(insert, signal);
+                    iterator.apply(r.rows[0]);
                     break;
                 case "modified":
                     // this will update the modified map
                     iterator.detect();
                     if (iterator.modified.size > 0) {
-                        const update = this.driver.createUpdateExpression(iterator);
-                        const r1 = await this.executeExpression(update, options);
-                        iterator.apply(r1 ?? {});
+                        // const update = this.driver.createUpdateExpression(iterator);
+                        const update = this.driver.updateQuery(iterator.type, iterator.entity, iterator.modified);
+                        const r1 = await connection.executeQuery(update, signal);
+                        iterator.apply(r1.rows?.[0] ?? {});
                     }
                     break;
                 case "deleted":
-                    const deleteQuery = this.driver.createDeleteExpression(iterator.type, iterator.entity);
+                    const deleteQuery = this.driver.deleteQuery(iterator.type, iterator.entity);
                     if (deleteQuery) {
-                        await this.executeExpression(deleteQuery, options);
+                        await connection.executeQuery(deleteQuery, signal);
                     }
                     iterator.apply({});
                     break;

package/src/model/EntitySource.ts

@@ -55,11 +55,124 @@ export type ISaveDirect<T> = {
     changes?: never
 };
 
-export class EntitySource<T = any> {
+export class EntityStatements<T = any> {
+
+    private readonly model: EntityType;
+    private readonly context: EntityContext;
+
+    constructor(private source: EntitySource<T>) {
+        this.model = source[modelSymbol];
+        this.context = source[contextSymbol];
+    }
+
+    async select(keys: Partial<T>, loadChangeEntry = false) {
+        const q = this.context.driver.selectQueryWithKeys(this.model, keys);
+        const r = await this.context.connection.executeQuery(q);
+        const result = r.rows[0];
+        if (loadChangeEntry) {
+            const ce = this.context.changeSet.getEntry(result);
+            ce.apply(result);
+            return ce.entity;
+        }
+        return result;
+    }
+
+    async insert(entity: Partial<T>, loadChangeEntry = false) {
+        const q = this.context.driver.insertQuery(this.model, entity);
+        const r = await this.context.connection.executeQuery(q);
+        const result = r.rows[0];
+        if (loadChangeEntry) {
+            const ce = this.context.changeSet.getEntry(result);
+            ce.apply(result);
+            return ce.entity;
+        }
+        return r.rows[0];
+    }
+
+    async update(entity: Partial<T>, loadChangeEntry = false) {
+        const q = this.context.driver.updateQuery(this.model, entity);
+        const r = await this.context.connection.executeQuery(q);
+        const result = r.rows?.[0];
+        if (loadChangeEntry) {
+            const ce = this.context.changeSet.getEntry(result);
+            ce.apply(result ?? {});
+            return ce.entity;
+        }
+        return r.rows[0];
+    }
+
+    async selectOrInsert(entity: Partial<T>, retry = 3) {
+        const tx = this.context.connection.currentTransaction;
+        let tid: string;
+        if (tx) {
+            tid = `txp_${Date.now()}`;
+            await tx.save(tid);
+        }
+
+        try {
+            const r = await this.select(entity);
+            if (r) {
+                return r;
+            }
+            return await this.insert(entity);
+        } catch (error) {
+            retry --;
+            if(retry > 0) {
+                if (tid) {
+                    await tx.rollbackTo(tid);
+                }
+                await sleep(300);
+                return await this.selectOrInsert(entity, retry);
+            }
+            throw error;
+        }
+    }
+
+    async upsert(entity: Partial<T>, updateAfterSelect: (x:T) => T, retry = 3) {
 
-    public statements = {
+        const tx = this.context.connection.currentTransaction;
+        let tid: string;
+        if (tx) {
+            tid = `txp_${Date.now()}`;
+            await tx.save(tid);
+        }
+
+        try {
+            if (updateAfterSelect) {
+                let existing = await this.select(entity);
+                if (existing) {
+                    existing = updateAfterSelect(existing);
+                    for (const key in entity) {
+                        if (Object.prototype.hasOwnProperty.call(entity, key)) {
+                            const element = entity[key];
+                            existing[key] = element;
+                        }
+                    }
+                    entity = existing;
+                }
+            }
+            const r = await this.update(entity);
+            if (r) {
+                return r;
+            }
+            return await this.insert(entity);
+        } catch (error) {
+            retry --;
+            if(retry > 0) {
+                if (tid) {
+                    await tx.rollbackTo(tid);
+                }
+                await sleep(300);
+                return await this.upsert(entity, updateAfterSelect, retry);
+            }
+            throw error;
+        }
+    }
+}
+
+export class EntitySource<T = any> {
 
-    };
+    public statements = new EntityStatements<T>(this);
 
     get [modelSymbol]() {
         return this.model;

package/src/model/changes/ChangeEntry.ts

@@ -239,12 +239,19 @@ export default class ChangeEntry<T = any> implements IChanges {
         // we will only apply the columns defined
         if (dbValues !== void 0) {
             const { entity, type } = this;
-            for (const iterator of type.columns) {
-                const dbValue = dbValues[iterator.columnName];
-                if (dbValue !== void 0) {
-                    entity[iterator.name] = dbValue;
+            for (const key in dbValues) {
+                if (Object.prototype.hasOwnProperty.call(dbValues, key)) {
+                    const element = dbValues[key];
+                    entity[key] = element;
                 }
             }
+            // const { entity, type } = this;
+            // for (const iterator of type.columns) {
+            //     const dbValue = dbValues[iterator.columnName];
+            //     if (dbValue !== void 0) {
+            //         entity[iterator.name] = dbValue;
+            //     }
+            // }
         }
 
         // we will set the identity key

package/tests/local-unit-tests/docker-compose.yml

@@ -20,7 +20,7 @@ services:
       - 5432:5432
   pgadmin:
     image: dpage/pgadmin4
-    container_name: pg-admin
+    container_name: pg-admin-test
     restart: unless-stopped
     environment:
       - PGADMIN_CONFIG_SERVER_MODE=False