orange-orm 3.10.2 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "3.10.2",
+  "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/getTSDefinition.js

@@ -53,14 +53,17 @@ export interface ${Name}Table {
 	getOne(${name}: ${Name}, fetchingStrategy: ${Name}Strategy): Promise<${Name}Row>;
 	getById(${getIdArgs(table)}): Promise<${Name}Row>;
 	getById(${getIdArgs(table)}, fetchingStrategy: ${Name}Strategy): Promise<${Name}Row>;
+
 	update(${name}s: ${Name}[]): Promise<${Name}Array>;
-	updateChanges(${name}s: ${Name}[], old${name}s: ${Name}[]): Promise<${Name}Array>;
 	update(${name}s: ${Name}[], fetchingStrategy: ${Name}Strategy): Promise<${Name}Array>;
-	updateChanges(${name}s: ${Name}[],old${name}s: ${Name}[], fetchingStrategy: ${Name}Strategy): Promise<${Name}Array>;
 	update(${name}: ${Name}): Promise<${Name}Row>;
-	updateChanges(${name}: ${Name}, old${name}: ${Name}): Promise<${Name}Row>;
 	update(${name}: ${Name}, fetchingStrategy: ${Name}Strategy): Promise<${Name}Row>;
-	updateChanges(${name}: ${Name},${name}: ${Name}, fetchingStrategy: ${Name}Strategy): Promise<${Name}Row>;
+
+	updateChanges(${name}s: ${Name}[], old${name}s: ${Name}[]): Promise<${Name}Array>;
+	updateChanges(${name}s: ${Name}[],old${name}s: ${Name}[], fetchingStrategy: ${Name}Strategy): Promise<${Name}Array>;
+	updateChanges(${name}: ${Name}, old${name}: ${Name}): Promise<${Name}Row>;
+	updateChanges(${name}: ${Name},old${name}: ${Name}, fetchingStrategy: ${Name}Strategy): Promise<${Name}Row>;
+	
 	insert(${name}s: ${Name}[]): Promise<${Name}Array>;
 	insert(${name}s: ${Name}[], fetchingStrategy: ${Name}Strategy): Promise<${Name}Array>;
 	insert(${name}: ${Name}): Promise<${Name}Row>;
@@ -82,11 +85,6 @@ export interface ${Name}Table {
 	${_tableRelations}
 }
 
-export interface ${Name}TableBase {	
-	${_columns}
-	${_tableRelations}
-}
-
 export interface ${Name}ExpressConfig {
 	baseFilter?: RawFilter | ((context: ExpressContext) => RawFilter | Promise<RawFilter>);
     customFilters?: Record<string, (context: ExpressContext,...args: any[]) => RawFilter | Promise<RawFilter>>;
@@ -224,6 +222,12 @@ export interface ${name} {
 	${regularRelations}
 }
 
+export interface ${name}TableBase {	
+	${columns(table)}
+	${tableRelations(table)}
+}
+
+
 export interface ${name}Strategy {
 	${strategyColumns(table)}
 	${strategyRelations}
@@ -350,9 +354,9 @@ function getPrefixTs(isNamespace) {
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { AxiosInterceptorManager, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
-import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Url, ColumnConcurrency, JsonPatch } from 'rdb';
+import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Url, ColumnConcurrency, JsonPatch } from 'orange-orm';
 export { RequestHandler } from 'express';
-export { Concurrency, Filter, RawFilter, Config, TransactionOptions, Pool } from 'rdb';
+export { Concurrency, Filter, RawFilter, Config, TransactionOptions, Pool } from 'orange-orm';
 export = r;
 declare function r(config: Config): r.RdbClient;
 `;
@@ -363,7 +367,7 @@ declare function r(config: Config): r.RdbClient;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import schema from './schema';
 import type { AxiosInterceptorManager, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
-import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Url, ColumnConcurrency, JsonPatch } from 'rdb';
+import type { BooleanColumn, JSONColumn, UUIDColumn, DateColumn, NumberColumn, BinaryColumn, StringColumn, Concurrency, Filter, RawFilter, TransactionOptions, Pool, Express, Url, ColumnConcurrency, JsonPatch } from 'orange-orm';
 export default schema as RdbClient;`;
 }
 

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;
 		}