metal-orm 1.0.99 → 1.0.101

package/README.md

@@ -127,6 +127,7 @@ On top of the query builder, MetalORM ships a focused runtime managed by `Orm` a
 - **Identity map**: the same row becomes the same entity instance within a session (see the [Identity map pattern](https://en.wikipedia.org/wiki/Identity_map_pattern)).
 - **Unit of Work (`OrmSession`)** tracking New/Dirty/Removed entities and relation changes, inspired by the classic [Unit of Work pattern](https://en.wikipedia.org/wiki/Unit_of_work).
 - **Graph persistence**: mutate a whole object graph and flush once with `session.commit()`.
+- **Partial updates**: use `session.patchGraph()` to update only specific fields of an entity and its relations (returns `null` if entity doesn't exist).
 - **Relation change processor** that knows how to deal with has-many and many-to-many pivot tables.
 - **Interceptors**: `beforeFlush` / `afterFlush` hooks for cross-cutting concerns (auditing, multi-tenant filters, soft delete filters, etc.).
 - **Domain events**: `addDomainEvent` and a DomainEventBus integrated into `session.commit()`, aligned with domain events from [Domain-driven design](https://en.wikipedia.org/wiki/Domain-driven_design).

package/dist/index.cjs

@@ -2302,11 +2302,14 @@ var SqlDialectBase = class extends Dialect {
   compileUpdateAssignments(assignments, table, ctx) {
     return assignments.map((assignment) => {
       const col2 = assignment.column;
-      const target = this.compileQualifiedColumn(col2, table);
+      const target = this.compileSetTarget(col2, table);
       const value = this.compileOperand(assignment.value, ctx);
       return `${target} = ${value}`;
     }).join(", ");
   }
+  compileSetTarget(column, table) {
+    return this.compileQualifiedColumn(column, table);
+  }
   compileQualifiedColumn(column, table) {
     const baseTableName = table.name;
     const alias = table.alias;
@@ -2649,6 +2652,12 @@ var PostgresDialect = class extends SqlDialectBase {
   supportsReturning() {
     return true;
   }
+  /**
+   * PostgreSQL requires unqualified column names in SET clause
+   */
+  compileSetTarget(column, _table) {
+    return this.quoteIdentifier(column.name);
+  }
 };
 
 // src/core/dialect/mysql/functions.ts
@@ -12214,6 +12223,14 @@ var saveGraphInternal = async (session, entityClass, payload, options = {}) => {
   await applyGraphToEntity(session, table, root, payload, options);
   return root;
 };
+var patchGraphInternal = async (session, entityClass, existing, payload, options = {}) => {
+  const table = getTableDefFromEntity(entityClass);
+  if (!table) {
+    throw new Error("Entity metadata has not been bootstrapped");
+  }
+  await applyGraphToEntity(session, table, existing, payload, options);
+  return existing;
+};
 
 // src/orm/orm-session.ts
 var OrmSession = class {
@@ -12474,6 +12491,33 @@ var OrmSession = class {
     }
     return this.transaction(() => execute());
   }
+  async patchGraph(entityClass, payload, options) {
+    const table = getTableDefFromEntity(entityClass);
+    if (!table) {
+      throw new Error("Entity metadata has not been bootstrapped");
+    }
+    const primaryKey = findPrimaryKey(table);
+    const pkValue = payload[primaryKey];
+    if (pkValue === void 0 || pkValue === null) {
+      throw new Error(`patchGraph requires a primary key value for "${primaryKey}"`);
+    }
+    const resolved = this.resolveSaveGraphOptions(options);
+    const { transactional = true, flush = false, ...graphOptions } = resolved;
+    const execute = async () => {
+      const tracked = this.getEntity(table, pkValue);
+      const existing = tracked ?? await this.find(entityClass, pkValue);
+      if (!existing) return null;
+      return patchGraphInternal(this, entityClass, existing, payload, graphOptions);
+    };
+    if (!transactional) {
+      const result = await execute();
+      if (result && flush) {
+        await this.flush();
+      }
+      return result;
+    }
+    return this.transaction(() => execute());
+  }
   /**
    * Persists an entity (either inserts or updates).
    * @param entity - The entity to persist