orange-orm 3.10.3 → 4.0.0

package/README.md

@@ -4,7 +4,7 @@
 
 The ultimate Object Relational Mapper for Node.js and Typescript, offering seamless integration with a variety of popular databases. Whether you're building applications in TypeScript or JavaScript  (including both CommonJS and ECMAScript), Orange ORM has got you covered.  
 
-[![npm version](https://img.shields.io/npm/v/rdb.svg?style=flat-square)](https://www.npmjs.org/package/orange-orm)
+[![npm version](https://img.shields.io/npm/v/orange-orm.svg?style=flat-square)](https://www.npmjs.org/package/orange-orm)
 [![Build status](https://github.com/alfateam/orange-orm/workflows/Node.js%20CI/badge.svg)](https://github.com/alfateam/orange-orm/actions)
 [![Coverage Badge](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/lroal/1a69422f03da7f8155cf94fe66022452/raw/rdb__heads_master.json)](https://github.com/alfateam/orange-orm/actions)
 [![Github](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/lroal/1ccb2b79abbe0258d636e9b5e4630a1a/raw/rdb__heads_master.json)](https://github.com/alfateam/orange-orm)
@@ -740,8 +740,8 @@ async function update() {
   await orders.saveChanges();
 }
 ```
-__Updating from JSON__  
-The update method is suitable when a complete overwrite is required from a JSON object - typically in a REST API. However, it's important to consider that this method replaces the entire row and it's children, which might not always be desirable in a multi-user environment.
+__Selective updates__  
+The update method is ideal for updating specific columns and relationships across one or multiple rows. You must provide a where filter to specify which rows to target. If you include a fetching strategy, the affected rows and their related data will be returned; otherwise, no data is returned.
 
 ```javascript
 import map from './map';
@@ -751,7 +751,33 @@ update();
 
 async function update() {
 
+  const propsToBeModified = {
+    orderDate: new Date(),
+    customerId: 2,
+    lines: [
+      { id: 1, product: 'Bicycle', amount: 250 }, //already existing line
+      { id: 2, product: 'Small guitar', amount: 150 }, //already existing line
+      { product: 'Piano', amount: 800 } //the new line to be inserted
+    ]
+  };
+
+  const strategy = {customer: true, deliveryAddress: true, lines: true};
+  const orders = await db.order.update(propsToBeModified, { where: x => x.id.eq(1) }, strategy);
+}
+```
+__Replacing a row from JSON__  
+The replace method is suitable when a complete overwrite is required from a JSON object - typically in a REST API. However, it's important to consider that this method replaces the entire row and it's children, which might not always be desirable in a multi-user environment.
+
+```javascript
+import map from './map';
+const db = map.sqlite('demo.db');
+
+replace();
+
+async function replace() {
+
   const modified = {
+    id: 1,
     orderDate: '2023-07-14T12:00:00',
     customer: {
       id: 2
@@ -770,7 +796,7 @@ async function update() {
     ]
   };
 
-  const order = await db.order.update(modified, {customer: true, deliveryAddress: true, lines: true});
+  const order = await db.order.replace(modified, {customer: true, deliveryAddress: true, lines: true});
 }
 ```
 __Partially updating from JSON__  

package/docs/changelog.md

@@ -1,13 +1,15 @@
 ## Changelog
-__3.10.3_  
+__4.0.0__  
+Changed the behaviour of `update` to accept a `where` filter and only update passed in columns and relations. The previous behaviour of `update` has moved to `replace` method.  
+__3.10.3__  
 Fix duplicate method signatures for those still using code generation  
-__3.10.2_  
+__3.10.2__  
 Orange ORM was renamed from rdb. New installation url: [npmjs.org/package/orange-orm](https://npmjs.org/package/orange-orm) . Old url was npmjs.org/package/rdb  
-__3.10.1_  
+__3.10.1__  
 Bugfix: Adding hasOne row to existing parent throws.  See [#86](https://github.com/alfateam/orange-orm/issues/86)  
-__3.10.0_  
+__3.10.0__  
 Aggregate functions  
-__3.9.1_  
+__3.9.1__  
 Bugfix: Crashing on many relations if foreign key column is omitted in strategy.  See [#83](https://github.com/alfateam/orange-orm/issues/83)  
 __3.9.0__  
 Possible to elevate associated column on a related table to a parent table when fetching.  See https://github.com/alfateam/orange-orm/#user-content-aggregate-results  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "3.10.3",
+  "version": "4.0.0",
   "main": "./src/index.js",
   "browser": "./src/client/index.mjs",
   "bin": {

package/src/client/index.js

@@ -190,6 +190,7 @@ function rdbClient(options = {}) {
 			getById,
 			proxify,
 			update,
+			replace,
 			updateChanges,
 			insert,
 			insertAndForget,
@@ -289,31 +290,32 @@ function rdbClient(options = {}) {
 		function negotiateWhere(_, strategy, ...rest) {
 			const args = Array.prototype.slice.call(arguments);
 			if (strategy)
-				return [_, where(strategy), ...rest];
+				return [_, negotiateWhereSingle(strategy), ...rest];
 			else
 				return args;
 
-			function where(_strategy, path = '') {
-				if (typeof _strategy !== 'object' || _strategy === null)
-					return _strategy;
 
-				if (Array.isArray(_strategy)) {
-					return _strategy.map(item => where(item, path));
-				}
+		}
 
-				const strategy = { ..._strategy };
-				for (let name in _strategy) {
-					if (name === 'where' && typeof strategy[name] === 'function')
-						strategy.where = column(path + 'where')(strategy.where); // Assuming `column` is defined elsewhere.
-					else if (typeof strategy[name] === 'function') {
-						strategy[name] = aggregate(path, strategy[name]);
-					}
-					else
-						strategy[name] = where(_strategy[name], path + name + '.');
-				}
-				return strategy;
+		function negotiateWhereSingle(_strategy, path = '') {
+			if (typeof _strategy !== 'object' || _strategy === null)
+				return _strategy;
+
+			if (Array.isArray(_strategy)) {
+				return _strategy.map(item => negotiateWhereSingle(item, path));
 			}
 
+			const strategy = { ..._strategy };
+			for (let name in _strategy) {
+				if (name === 'where' && typeof strategy[name] === 'function')
+					strategy.where = column(path + 'where')(strategy.where); // Assuming `column` is defined elsewhere.
+				else if (typeof strategy[name] === 'function') {
+					strategy[name] = aggregate(path, strategy[name]);
+				}
+				else
+					strategy[name] = negotiateWhereSingle(_strategy[name], path + name + '.');
+			}
+			return strategy;
 		}
 
 
@@ -372,28 +374,34 @@ function rdbClient(options = {}) {
 			return adapter.post(body);
 		}
 
-		async function update(rows, ...rest) {
-			const concurrency = undefined;
-			const args = [concurrency].concat(rest);
-			if (Array.isArray(rows)) {
-				const proxy = await getMany.apply(null, [rows, ...rest]);
-				proxy.splice.apply(proxy, [0, proxy.length, ...rows]);
-				await proxy.saveChanges.apply(proxy, args);
-				return proxy;
-			}
-			else {
-				const proxy = await getMany.apply(null, [[rows], ...rest]);
-				proxy.splice.apply(proxy, [0, 1, rows]);
-				await proxy.saveChanges.apply(proxy, args);
-				return proxify(proxy[0], args[0]);
-			}
+		async function update(_row, _where, strategy) {
+			let args = [_row, negotiateWhereSingle(_where), negotiateWhereSingle(strategy)];
+			let body = stringify({
+				path: 'update',
+				args
+			});
+			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
+			const result =  await adapter.post(body);
+			if (strategy)
+				return proxify(result, strategy);
+		}
+
+		async function replace(_row, strategy) {
+			let args = [_row, negotiateWhereSingle(strategy)];
+			let body = stringify({
+				path: 'replace',
+				args
+			});
+			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
+			const result =  await adapter.post(body);
+			if (strategy)
+				return proxify(result, strategy);
 		}
 
 		async function updateChanges(rows, oldRows, ...rest) {
 			const concurrency = undefined;
 			const args = [concurrency].concat(rest);
 			if (Array.isArray(rows)) {
-				//todo
 				const proxy = await getMany.apply(null, [rows, ...rest]);
 				proxy.splice.apply(proxy, [0, proxy.length, ...rows]);
 				await proxy.saveChanges.apply(proxy, args);

package/src/client/index.mjs

@@ -5486,6 +5486,7 @@ function rdbClient(options = {}) {
 			getById,
 			proxify,
 			update,
+			replace,
 			updateChanges,
 			insert,
 			insertAndForget,
@@ -5585,31 +5586,32 @@ function rdbClient(options = {}) {
 		function negotiateWhere(_, strategy, ...rest) {
 			const args = Array.prototype.slice.call(arguments);
 			if (strategy)
-				return [_, where(strategy), ...rest];
+				return [_, negotiateWhereSingle(strategy), ...rest];
 			else
 				return args;
 
-			function where(_strategy, path = '') {
-				if (typeof _strategy !== 'object' || _strategy === null)
-					return _strategy;
 
-				if (Array.isArray(_strategy)) {
-					return _strategy.map(item => where(item, path));
-				}
+		}
 
-				const strategy = { ..._strategy };
-				for (let name in _strategy) {
-					if (name === 'where' && typeof strategy[name] === 'function')
-						strategy.where = column(path + 'where')(strategy.where); // Assuming `column` is defined elsewhere.
-					else if (typeof strategy[name] === 'function') {
-						strategy[name] = aggregate(path, strategy[name]);
-					}
-					else
-						strategy[name] = where(_strategy[name], path + name + '.');
-				}
-				return strategy;
+		function negotiateWhereSingle(_strategy, path = '') {
+			if (typeof _strategy !== 'object' || _strategy === null)
+				return _strategy;
+
+			if (Array.isArray(_strategy)) {
+				return _strategy.map(item => negotiateWhereSingle(item, path));
 			}
 
+			const strategy = { ..._strategy };
+			for (let name in _strategy) {
+				if (name === 'where' && typeof strategy[name] === 'function')
+					strategy.where = column(path + 'where')(strategy.where); // Assuming `column` is defined elsewhere.
+				else if (typeof strategy[name] === 'function') {
+					strategy[name] = aggregate(path, strategy[name]);
+				}
+				else
+					strategy[name] = negotiateWhereSingle(_strategy[name], path + name + '.');
+			}
+			return strategy;
 		}
 
 
@@ -5668,28 +5670,34 @@ function rdbClient(options = {}) {
 			return adapter.post(body);
 		}
 
-		async function update(rows, ...rest) {
-			const concurrency = undefined;
-			const args = [concurrency].concat(rest);
-			if (Array.isArray(rows)) {
-				const proxy = await getMany.apply(null, [rows, ...rest]);
-				proxy.splice.apply(proxy, [0, proxy.length, ...rows]);
-				await proxy.saveChanges.apply(proxy, args);
-				return proxy;
-			}
-			else {
-				const proxy = await getMany.apply(null, [[rows], ...rest]);
-				proxy.splice.apply(proxy, [0, 1, rows]);
-				await proxy.saveChanges.apply(proxy, args);
-				return proxify(proxy[0], args[0]);
-			}
+		async function update(_row, _where, strategy) {
+			let args = [_row, negotiateWhereSingle(_where), negotiateWhereSingle(strategy)];
+			let body = stringify({
+				path: 'update',
+				args
+			});
+			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
+			const result =  await adapter.post(body);
+			if (strategy)
+				return proxify(result, strategy);
+		}
+
+		async function replace(_row, strategy) {
+			let args = [_row, negotiateWhereSingle(strategy)];
+			let body = stringify({
+				path: 'replace',
+				args
+			});
+			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
+			const result =  await adapter.post(body);
+			if (strategy)
+				return proxify(result, strategy);
 		}
 
 		async function updateChanges(rows, oldRows, ...rest) {
 			const concurrency = undefined;
 			const args = [concurrency].concat(rest);
 			if (Array.isArray(rows)) {
-				//todo
 				const proxy = await getMany.apply(null, [rows, ...rest]);
 				proxy.splice.apply(proxy, [0, proxy.length, ...rows]);
 				await proxy.saveChanges.apply(proxy, args);

package/src/hostExpress/executePath.js

@@ -1,4 +1,5 @@
-let emptyFilter = require('../emptyFilter');
+const createPatch = require('../client/createPatch');
+const emptyFilter = require('../emptyFilter');
 const negotiateRawSqlFilter = require('../table/column/negotiateRawSqlFilter');
 let getMeta = require('./getMeta');
 let isSafe = Symbol();
@@ -70,7 +71,8 @@ let _allowedOps = {
 
 async function executePath({ table, JSONFilter, baseFilter, customFilters = {}, request, response, readonly, disableBulkDeletes, isHttp, client }) {
 	let allowedOps = { ..._allowedOps, insert: !readonly, ...extractRelations(getMeta(table)) };
-	let ops = { ..._ops, ...getCustomFilterPaths(customFilters), getManyDto, getMany, aggregate, count, delete: _delete, cascadeDelete };
+	let ops = { ..._ops, ...getCustomFilterPaths(customFilters), getManyDto, getMany, aggregate, count, delete: _delete, cascadeDelete, update, replace };
+
 	let res = await parseFilter(JSONFilter, table);
 	if (res === undefined)
 		return {};
@@ -85,7 +87,7 @@ async function executePath({ table, JSONFilter, baseFilter, customFilters = {},
 			if (anyAllNone) {
 				if (isHttp)
 					validateArgs(json.args[0]);
-				const f =  anyAllNone(x => parseFilter(json.args[0], x));
+				const f = anyAllNone(x => parseFilter(json.args[0], x));
 				f.isSafe = isSafe;
 				return f;
 			}
@@ -114,7 +116,7 @@ async function executePath({ table, JSONFilter, baseFilter, customFilters = {},
 			let ops = new Set(['all', 'any', 'none', 'where', '_aggregate']);
 			// let ops = new Set(['all', 'any', 'none', 'where']);
 			let last = path.slice(-1)[0];
-			if (ops.has(last) || (table &&  (table._primaryColumns || (table.any && table.all))))
+			if (ops.has(last) || (table && (table._primaryColumns || (table.any && table.all))))
 				return table;
 		}
 
@@ -136,7 +138,7 @@ async function executePath({ table, JSONFilter, baseFilter, customFilters = {},
 			let op = pathArray[pathArray.length - 1];
 			if (!allowedOps[op] && isHttp) {
 
-				let e =  new Error('Disallowed operator ' + op);
+				let e = new Error('Disallowed operator ' + op);
 				// @ts-ignore
 				e.status = 403;
 				throw e;
@@ -146,6 +148,8 @@ async function executePath({ table, JSONFilter, baseFilter, customFilters = {},
 				target = target[pathArray[i]];
 			}
 
+			if (!target)
+				throw new Error(`Method '${path}' does not exist`);
 			let res = target.apply(null, args);
 			setSafe(res);
 			return res;
@@ -272,6 +276,66 @@ async function executePath({ table, JSONFilter, baseFilter, customFilters = {},
 		return table.getManyDto.apply(null, args);
 	}
 
+	async function replace(subject, strategy = { insertAndForget: true }) {
+		validateStrategy(table, strategy);
+		const refinedStrategy = objectToStrategy(subject, {}, table);
+		const JSONFilter2 = {
+			path: 'getManyDto',
+			args: [subject, refinedStrategy]
+		};
+		const originals = await executePath({ table, JSONFilter: JSONFilter2, baseFilter, customFilters, request, response, readonly, disableBulkDeletes, isHttp, client });
+		const meta = getMeta(table);
+		const patch = createPatch(originals, Array.isArray(subject) ? subject : [subject], meta);
+		const { changed } =  await table.patch(patch, { strategy });
+		if (Array.isArray(subject))
+			return changed;
+		else
+			return changed[0];
+	}
+
+	async function update(subject, whereStrategy, strategy = { insertAndForget: true }) {
+		validateStrategy(table, strategy);
+		const refinedWhereStrategy = objectToStrategy(subject, whereStrategy, table);
+		const JSONFilter2 = {
+			path: 'getManyDto',
+			args: [null, refinedWhereStrategy]
+		};
+		const rows = await executePath({ table, JSONFilter: JSONFilter2, baseFilter, customFilters, request, response, readonly, disableBulkDeletes, isHttp, client });
+		const originals = new Array(rows.length);
+		for (let i = 0; i < rows.length; i++) {
+			const row = rows[i];
+			originals[i] = { ...row };
+			for (let p in subject) {
+				row[p] = subject[p];
+			}
+		}
+		const meta = getMeta(table);
+		const patch = createPatch(originals, rows, meta);
+		const { changed } =  await table.patch(patch, { strategy });
+		return changed;
+	}
+
+	function objectToStrategy(object, whereStrategy, table, strategy = {}) {
+		strategy = {...whereStrategy, ...strategy};
+		if (Array.isArray(object)) {
+			for (let i = 0; i < object.length; i++) {
+				objectToStrategy(object[i], table, strategy);
+			}
+			return;
+		}
+		for (let name in object) {
+			const relation =  table[name]?._relation;
+			if (relation && !relation.columns) {//notJoin, that is one or many
+				strategy[name] = {};
+				objectToStrategy(object[name], whereStrategy?.[name], table[name], strategy[name]);
+			}
+			else
+				strategy[name] = true;
+		}
+		return strategy;
+	}
+
+
 	async function aggregate(filter, strategy) {
 		validateStrategy(table, strategy);
 		filter = negotiateFilter(filter);
@@ -283,11 +347,13 @@ async function executePath({ table, JSONFilter, baseFilter, customFilters = {},
 		return table.aggregate.apply(null, args);
 	}
 
+
+
 	async function negotiateWhereAndAggregate(strategy) {
 		if (typeof strategy !== 'object')
 			return;
 
-		for(let name in strategy) {
+		for (let name in strategy) {
 			const target = strategy[name];
 			if (isFilter(target))
 				strategy[name] = await parseFilter(strategy[name], table);
@@ -325,7 +391,7 @@ function validateStrategy(table, strategy) {
 function validateLimit(strategy) {
 	if (!('limit' in strategy) || Number.isInteger(strategy.limit))
 		return;
-	const e =  new Error('Invalid limit: ' + strategy.limit);
+	const e = new Error('Invalid limit: ' + strategy.limit);
 	// @ts-ignore
 	e.status = 400;
 }
@@ -333,7 +399,7 @@ function validateLimit(strategy) {
 function validateOffset(strategy) {
 	if (!('offset' in strategy) || Number.isInteger(strategy.offset))
 		return;
-	const e =  new Error('Invalid offset: ' + strategy.offset);
+	const e = new Error('Invalid offset: ' + strategy.offset);
 	// @ts-ignore
 	e.status = 400;
 	throw e;

package/src/hostExpress/getMeta.js

@@ -1,10 +1,3 @@
-let extractSubStrategy = _extractSubStrategy;
-
-function _extractSubStrategy(table, map) {
-	extractSubStrategy = require('./getMeta');
-	return extractSubStrategy(table, map);
-}
-
 function getMeta(table, map = new Map()) {
 	if (map.has(table))
 		return map.get(table).id;
@@ -30,11 +23,11 @@ function getMeta(table, map = new Map()) {
 
 	let visitor = {};
 	visitor.visitJoin = function(relation) {
-		strategy.relations[relationName] = extractSubStrategy(relation.childTable, map);
+		strategy.relations[relationName] = getMeta(relation.childTable, map);
 	};
 
 	visitor.visitMany = function(relation) {
-		strategy.relations[relationName] = extractSubStrategy(relation.childTable, map);
+		strategy.relations[relationName] = getMeta(relation.childTable, map);
 	};
 
 	visitor.visitOne = visitor.visitMany;

package/src/map.d.ts

@@ -167,37 +167,48 @@ type ExpandedMappedTable<T, FL = ExpandedFetchingStrategy<T>> = {
 		fetchingStrategy?: FS
 	): Promise<StrategyToRow<FetchedProperties<T, FL>, T>>;
 
-
 	update(
-		row: StrategyToInsertRowData<T>
+		values: StrategyToUpdateRowData<T>,
+		where: FetchingStrategy<T>
+	): Promise<void>;
+
+	update<FS extends FetchingStrategy<T>>(
+		values: StrategyToUpdateRowData<T>,
+		where: FetchingStrategy<T>,
+		strategy: FS
+	): Promise<StrategyToRowArray<FetchedProperties<T, FL>, T>>;
+
+	replace(
+		row: StrategyToInsertRowData<T> | StrategyToInsertRowData<T>[]
+	): Promise<void>;
+	
+	replace<FS extends FetchingStrategy<T>>(
+		row: StrategyToInsertRowData<T>,
+		strategy: FS
 	): Promise<StrategyToRow<FetchedProperties<T, FL>, T>>;
+
+	replace<FS extends FetchingStrategy<T>>(
+		rows: StrategyToInsertRowData<T>[],
+		strategy: FS
+	): Promise<StrategyToRowArray<FetchedProperties<T, FL>, T>>;
+
+
 	updateChanges(
 		row: StrategyToInsertRowData<T>,
 		originalRow: StrategyToInsertRowData<T>
 	): Promise<StrategyToRow<FetchedProperties<T, FL>, T>>;
 
-	update(
-		rows: StrategyToInsertRowData<T>[]
-	): Promise<StrategyToRowArray<FetchedProperties<T, FL>, T>>;
 	updateChanges(
 		rows: StrategyToInsertRowData<T>[],
 		originalRows: StrategyToInsertRowData<T>[]
 	): Promise<StrategyToRowArray<FetchedProperties<T, FL>, T>>;
 
-	update<FS extends FetchingStrategy<T>>(
-		row: StrategyToInsertRowData<T>,
-		strategy: FS
-	): Promise<StrategyToRow<FetchedProperties<T, FL>, T>>;
 	updateChanges<FS extends FetchingStrategy<T>>(
 		row: StrategyToInsertRowData<T>,
 		originalRow: StrategyToInsertRowData<T>,
 		strategy: FS
 	): Promise<StrategyToRow<FetchedProperties<T, FL>, T>>;
 
-	update<FS extends FetchingStrategy<T>>(
-		rows: StrategyToInsertRowData<T>[],
-		strategy: FS
-	): Promise<StrategyToRowArray<FetchedProperties<T, FL>, T>>;
 	updateChanges<FS extends FetchingStrategy<T>>(
 		rows: StrategyToInsertRowData<T>[],
 		originalRows: StrategyToInsertRowData<T>[],
@@ -295,37 +306,49 @@ type MappedTable<T> = {
 		filter?: Filter | PrimaryRowFilter<T>,
 		fetchingStrategy?: FS
 	): Promise<StrategyToRow<FetchedProperties<T, FS>, T>>;
-
+	
 	update(
-		row: StrategyToInsertRowData<T>
-	): Promise<StrategyToRow<FetchedProperties<T, {}>, T>>;
+		values: StrategyToUpdateRowData<T>,
+		where: FetchingStrategy<T>
+	): Promise<void>;
+
+	update<FS extends FetchingStrategy<T>>(
+		values: StrategyToUpdateRowData<T>,
+		where: FetchingStrategy<T>,
+		strategy: FS
+	): Promise<StrategyToRowArray<FetchedProperties<T, FS>, T>>;
+
+	replace(
+		row: StrategyToInsertRowData<T> | StrategyToInsertRowData<T>[]
+	): Promise<void>;
+	
+	replace<FS extends FetchingStrategy<T>>(
+		row: StrategyToInsertRowData<T>,
+		strategy: FS
+	): Promise<StrategyToRow<FetchedProperties<T, FS>, T>>;
+
+	replace<FS extends FetchingStrategy<T>>(
+		rows: StrategyToInsertRowData<T>[],
+		strategy: FS
+	): Promise<StrategyToRowArray<FetchedProperties<T, FS>, T>>;
+
 	updateChanges(
 		modifiedRow: StrategyToInsertRowData<T>,
 		originalRow: StrategyToInsertRowData<T>
 	): Promise<StrategyToRow<FetchedProperties<T, {}>, T>>;
 
-	update(
-		rows: StrategyToInsertRowData<T>[]
-	): Promise<StrategyToRowArray<FetchedProperties<T, {}>, T>>;
+
 	updateChanges(
 		modifiedRows: StrategyToInsertRowData<T>[],
 		originalRows: StrategyToInsertRowData<T>[]
 	): Promise<StrategyToRowArray<FetchedProperties<T, {}>, T>>;
 
-	update<FS extends FetchingStrategy<T>>(
-		row: StrategyToInsertRowData<T>,
-		strategy: FS
-	): Promise<StrategyToRow<FetchedProperties<T, FS>, T>>;
 	updateChanges<FS extends FetchingStrategy<T>>(
 		modifiedRow: StrategyToInsertRowData<T>,
 		originalRow: StrategyToInsertRowData<T>,
 		strategy: FS
 	): Promise<StrategyToRow<FetchedProperties<T, FS>, T>>;
 
-	update<FS extends FetchingStrategy<T>>(
-		rows: StrategyToInsertRowData<T>[],
-		strategy: FS
-	): Promise<StrategyToRowArray<FetchedProperties<T, FS>, T>>;
 	updateChanges<FS extends FetchingStrategy<T>>(
 		modifiedRows: StrategyToInsertRowData<T>[],
 		originalRows: StrategyToInsertRowData<T>[],
@@ -1155,6 +1178,31 @@ type StrategyToRowData<T> = {
 		: StrategyToRowData<T[K]>;
 	};
 
+type StrategyToUpdateRowData<T> = Omit<{
+	[K in keyof T]?: T[K] extends StringColumnSymbol
+	? string
+	: T[K] extends UuidColumnSymbol
+	? string
+	: T[K] extends NumericColumnSymbol
+	? number
+	: T[K] extends DateColumnSymbol
+	? string | Date
+	: T[K] extends DateWithTimeZoneColumnSymbol
+	? string | Date
+	: T[K] extends BinaryColumnSymbol
+	? string
+	: T[K] extends BooleanColumnSymbol
+	? boolean
+	: T[K] extends JsonOf<infer M>
+	? M
+	: T[K] extends JSONColumnSymbol
+	? JsonType
+	: T[K] extends ManyRelation
+	? StrategyToInsertRowData<T[K]>[]
+	: StrategyToInsertRowData<T[K]>;
+	}, 'formulaDiscriminators' | 'columnDiscriminators' | 'map' | ' isManyRelation' | ' relatedTable' | ' isOneRelation'>
+	;
+
 type StrategyToInsertRowData<T> = Omit<{
 	[K in keyof RemoveNever<
 		NotNullInsertProperties<T>

package/src/validateDeleteConflict.js

@@ -31,7 +31,7 @@ async function validateDeleteConflict({ row, oldValue, options, table }) {
 				let childRow = await childTable.tryGetById.apply(null, JSON.parse(name));
 				if (!childRow)
 					throw new Error(`${p} with id ${name} was deleted by another user`);
-				if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p][name], defaultConcurrency, concurrency: concurrency[p], table: childTable }))
+				if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p][name], options: inferOptions(options, p), table: childTable }))
 					return false;
 			}
 		}
@@ -40,7 +40,7 @@ async function validateDeleteConflict({ row, oldValue, options, table }) {
 			let childRow = await row[p];
 			if (!childRow)
 				throw new Error(`${p} was deleted by another user`);
-			if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p], defaultConcurrency, concurrency: concurrency[p], table: childTable }))
+			if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p], options: inferOptions(options, p), table: childTable }))
 				return false;
 		}