@anthonyalayo/drizzle-kit 1.0.1

package/src/jsonDiffer.js

@@ -0,0 +1,882 @@
+'use-strict';
+import { diff } from 'json-diff';
+
+export function diffForRenamedTables(pairs) {
+	// raname table1 to name of table2, so we can apply diffs
+	const renamed = pairs.map((it) => {
+		const from = it.from;
+		const to = it.to;
+		const newFrom = { ...from, name: to.name };
+		return [newFrom, to];
+	});
+
+	// find any alternations made to a renamed table
+	const altered = renamed.map((pair) => {
+		return diffForRenamedTable(pair[0], pair[1]);
+	});
+
+	return altered;
+}
+
+function diffForRenamedTable(t1, t2) {
+	t1.name = t2.name;
+	const diffed = diff(t1, t2) || {};
+	diffed.name = t2.name;
+
+	return findAlternationsInTable(diffed, t2.schema);
+}
+
+export function diffForRenamedColumn(t1, t2) {
+	const renamed = { ...t1, name: t2.name };
+	const diffed = diff(renamed, t2) || {};
+	diffed.name = t2.name;
+
+	return alternationsInColumn(diffed);
+}
+
+const update1to2 = (json) => {
+	Object.entries(json).forEach(([key, val]) => {
+		if ('object' !== typeof val) return;
+
+		if (val.hasOwnProperty('references')) {
+			const ref = val['references'];
+			const fkName = ref['foreignKeyName'];
+			const table = ref['table'];
+			const column = ref['column'];
+			const onDelete = ref['onDelete'];
+			const onUpdate = ref['onUpdate'];
+			const newRef = `${fkName};${table};${column};${onDelete ?? ''};${onUpdate ?? ''}`;
+			val['references'] = newRef;
+		} else {
+			update1to2(val);
+		}
+	});
+};
+
+const mapArraysDiff = (source, diff) => {
+	const sequence = [];
+	let sourceIndex = 0;
+	for (let i = 0; i < diff.length; i++) {
+		const it = diff[i];
+		if (it.length === 1) {
+			sequence.push({ type: 'same', value: source[sourceIndex] });
+			sourceIndex += 1;
+		} else {
+			if (it[0] === '-') {
+				sequence.push({ type: 'removed', value: it[1] });
+			} else {
+				sequence.push({ type: 'added', value: it[1], before: '' });
+			}
+		}
+	}
+	const result = sequence.reverse().reduce(
+		(acc, it) => {
+			if (it.type === 'same') {
+				acc.prev = it.value;
+			}
+
+			if (it.type === 'added' && acc.prev) {
+				it.before = acc.prev;
+			}
+			acc.result.push(it);
+			return acc;
+		},
+		{ result: [] },
+	);
+
+	return result.result.reverse();
+};
+
+export function diffSchemasOrTables(left, right) {
+	left = JSON.parse(JSON.stringify(left));
+	right = JSON.parse(JSON.stringify(right));
+
+	const result = Object.entries(diff(left, right) ?? {});
+
+	const added = result
+		.filter((it) => it[0].endsWith('__added'))
+		.map((it) => it[1]);
+	const deleted = result
+		.filter((it) => it[0].endsWith('__deleted'))
+		.map((it) => it[1]);
+
+	return { added, deleted };
+}
+
+export function diffIndPolicies(left, right) {
+	left = JSON.parse(JSON.stringify(left));
+	right = JSON.parse(JSON.stringify(right));
+
+	const result = Object.entries(diff(left, right) ?? {});
+
+	const added = result
+		.filter((it) => it[0].endsWith('__added'))
+		.map((it) => it[1]);
+	const deleted = result
+		.filter((it) => it[0].endsWith('__deleted'))
+		.map((it) => it[1]);
+
+	return { added, deleted };
+}
+
+export function diffColumns(left, right) {
+	left = JSON.parse(JSON.stringify(left));
+	right = JSON.parse(JSON.stringify(right));
+	const result = diff(left, right) ?? {};
+
+	const alteredTables = Object.fromEntries(
+		Object.entries(result)
+			.filter((it) => {
+				return !(it[0].includes('__added') || it[0].includes('__deleted'));
+			})
+			.map((tableEntry) => {
+				// const entry = { name: it, ...result[it] }
+				const deletedColumns = Object.entries(tableEntry[1].columns ?? {})
+					.filter((it) => {
+						return it[0].endsWith('__deleted');
+					})
+					.map((it) => {
+						return it[1];
+					});
+
+				const addedColumns = Object.entries(tableEntry[1].columns ?? {})
+					.filter((it) => {
+						return it[0].endsWith('__added');
+					})
+					.map((it) => {
+						return it[1];
+					});
+
+				tableEntry[1].columns = {
+					added: addedColumns,
+					deleted: deletedColumns,
+				};
+				const table = left[tableEntry[0]];
+				return [
+					tableEntry[0],
+					{ name: table.name, schema: table.schema, ...tableEntry[1] },
+				];
+			}),
+	);
+
+	return alteredTables;
+}
+
+export function diffPolicies(left, right) {
+	left = JSON.parse(JSON.stringify(left));
+	right = JSON.parse(JSON.stringify(right));
+	const result = diff(left, right) ?? {};
+
+	const alteredTables = Object.fromEntries(
+		Object.entries(result)
+			.filter((it) => {
+				return !(it[0].includes('__added') || it[0].includes('__deleted'));
+			})
+			.map((tableEntry) => {
+				// const entry = { name: it, ...result[it] }
+				const deletedPolicies = Object.entries(tableEntry[1].policies ?? {})
+					.filter((it) => {
+						return it[0].endsWith('__deleted');
+					})
+					.map((it) => {
+						return it[1];
+					});
+
+				const addedPolicies = Object.entries(tableEntry[1].policies ?? {})
+					.filter((it) => {
+						return it[0].endsWith('__added');
+					})
+					.map((it) => {
+						return it[1];
+					});
+
+				tableEntry[1].policies = {
+					added: addedPolicies,
+					deleted: deletedPolicies,
+				};
+				const table = left[tableEntry[0]];
+				return [
+					tableEntry[0],
+					{ name: table.name, schema: table.schema, ...tableEntry[1] },
+				];
+			}),
+	);
+
+	return alteredTables;
+}
+
+export function applyJsonDiff(json1, json2) {
+	json1 = JSON.parse(JSON.stringify(json1));
+	json2 = JSON.parse(JSON.stringify(json2));
+
+	// deep copy, needed because of the bug in diff library
+	const rawDiff = diff(json1, json2);
+
+	const difference = JSON.parse(JSON.stringify(rawDiff || {}));
+	difference.schemas = difference.schemas || {};
+	difference.tables = difference.tables || {};
+	difference.domains = difference.domains || {};
+	difference.enums = difference.enums || {};
+	difference.sequences = difference.sequences || {};
+	difference.roles = difference.roles || {};
+	difference.policies = difference.policies || {};
+	difference.views = difference.views || {};
+
+	// remove added/deleted schemas
+	const schemaKeys = Object.keys(difference.schemas);
+	for (let key of schemaKeys) {
+		if (key.endsWith('__added') || key.endsWith('__deleted')) {
+			delete difference.schemas[key];
+			continue;
+		}
+	}
+
+	// remove added/deleted tables
+	const tableKeys = Object.keys(difference.tables);
+	for (let key of tableKeys) {
+		if (key.endsWith('__added') || key.endsWith('__deleted')) {
+			delete difference.tables[key];
+			continue;
+		}
+
+		// supply table name and schema for altered tables
+		const table = json1.tables[key];
+		difference.tables[key] = {
+			name: table.name,
+			schema: table.schema,
+			...difference.tables[key],
+		};
+	}
+
+	for (let [tableKey, tableValue] of Object.entries(difference.tables)) {
+		const table = difference.tables[tableKey];
+		const columns = tableValue.columns || {};
+		const columnKeys = Object.keys(columns);
+		for (let key of columnKeys) {
+			if (key.endsWith('__added') || key.endsWith('__deleted')) {
+				delete table.columns[key];
+				continue;
+			}
+		}
+
+		if (Object.keys(columns).length === 0) {
+			delete table['columns'];
+		}
+
+		if (
+			'name' in table
+			&& 'schema' in table
+			&& Object.keys(table).length === 2
+		) {
+			delete difference.tables[tableKey];
+		}
+	}
+
+	const domainsEntries = Object.entries(difference.domains);
+	const alteredDomains = domainsEntries
+		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')))
+		.map((it) => {
+			const domainEntry = json1.domains[it[0]];
+			if (!domainEntry) return;
+			const { name, schema, baseType, notNull, defaultValue, checkConstraints } = domainEntry;
+			return { name, schema, baseType, notNull, defaultValue, checkConstraints };
+		}).filter(Boolean);
+
+	const enumsEntries = Object.entries(difference.enums);
+	const alteredEnums = enumsEntries
+		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')))
+		.map((it) => {
+			const enumEntry = json1.enums[it[0]];
+			const { name, schema, values } = enumEntry;
+
+			const sequence = mapArraysDiff(values, it[1].values);
+			const addedValues = sequence
+				.filter((it) => it.type === 'added')
+				.map((it) => {
+					return {
+						before: it.before,
+						value: it.value,
+					};
+				});
+			const deletedValues = sequence
+				.filter((it) => it.type === 'removed')
+				.map((it) => it.value);
+
+			return { name, schema, addedValues, deletedValues };
+		});
+
+	const sequencesEntries = Object.entries(difference.sequences);
+	const alteredSequences = sequencesEntries
+		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')) && 'values' in it[1])
+		.map((it) => {
+			return json2.sequences[it[0]];
+		});
+
+	const rolesEntries = Object.entries(difference.roles);
+	const alteredRoles = rolesEntries
+		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')))
+		.map((it) => {
+			return json2.roles[it[0]];
+		});
+
+	const policiesEntries = Object.entries(difference.policies);
+	const alteredPolicies = policiesEntries
+		.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted')))
+		.map((it) => {
+			return json2.policies[it[0]];
+		});
+
+	const viewsEntries = Object.entries(difference.views);
+
+	const alteredViews = viewsEntries.filter((it) => !(it[0].includes('__added') || it[0].includes('__deleted'))).map(
+		([nameWithSchema, view]) => {
+			const deletedWithOption = view.with__deleted;
+
+			const addedWithOption = view.with__added;
+
+			const deletedWith = Object.fromEntries(
+				Object.entries(view.with || {}).filter((it) => it[0].endsWith('__deleted')).map(([key, value]) => {
+					return [key.replace('__deleted', ''), value];
+				}),
+			);
+
+			const addedWith = Object.fromEntries(
+				Object.entries(view.with || {}).filter((it) => it[0].endsWith('__added')).map(([key, value]) => {
+					return [key.replace('__added', ''), value];
+				}),
+			);
+
+			const alterWith = Object.fromEntries(
+				Object.entries(view.with || {}).filter((it) =>
+					typeof it[1].__old !== 'undefined' && typeof it[1].__new !== 'undefined'
+				).map(
+					(it) => {
+						return [it[0], it[1].__new];
+					},
+				),
+			);
+
+			const alteredSchema = view.schema;
+
+			const alteredDefinition = view.definition;
+
+			const alteredExisting = view.isExisting;
+
+			const addedTablespace = view.tablespace__added;
+			const droppedTablespace = view.tablespace__deleted;
+			const alterTablespaceTo = view.tablespace;
+
+			let alteredTablespace;
+			if (addedTablespace) alteredTablespace = { __new: addedTablespace, __old: 'pg_default' };
+			if (droppedTablespace) alteredTablespace = { __new: 'pg_default', __old: droppedTablespace };
+			if (alterTablespaceTo) alteredTablespace = alterTablespaceTo;
+
+			const addedUsing = view.using__added;
+			const droppedUsing = view.using__deleted;
+			const alterUsingTo = view.using;
+
+			let alteredUsing;
+			if (addedUsing) alteredUsing = { __new: addedUsing, __old: 'heap' };
+			if (droppedUsing) alteredUsing = { __new: 'heap', __old: droppedUsing };
+			if (alterUsingTo) alteredUsing = alterUsingTo;
+
+			const alteredMeta = view.meta;
+
+			return Object.fromEntries(
+				Object.entries({
+					name: json2.views[nameWithSchema].name,
+					schema: json2.views[nameWithSchema].schema,
+					// pg
+					deletedWithOption: deletedWithOption,
+					addedWithOption: addedWithOption,
+					deletedWith: Object.keys(deletedWith).length ? deletedWith : undefined,
+					addedWith: Object.keys(addedWith).length ? addedWith : undefined,
+					alteredWith: Object.keys(alterWith).length ? alterWith : undefined,
+					alteredSchema,
+					alteredTablespace,
+					alteredUsing,
+					// mysql
+					alteredMeta,
+					// common
+					alteredDefinition,
+					alteredExisting,
+				}).filter(([_, value]) => value !== undefined),
+			);
+		},
+	);
+
+	const alteredTablesWithColumns = Object.values(difference.tables).map(
+		(table) => {
+			return findAlternationsInTable(table);
+		},
+	);
+
+	return {
+		alteredTablesWithColumns,
+		alteredDomains,
+		alteredEnums,
+		alteredSequences,
+		alteredRoles,
+		alteredViews,
+		alteredPolicies,
+	};
+}
+
+const findAlternationsInTable = (table) => {
+	// map each table to have altered, deleted or renamed columns
+
+	// in case no columns were altered, but indexes were
+	const columns = table.columns ?? {};
+
+	const altered = Object.keys(columns)
+		.filter((it) => !(it.includes('__deleted') || it.includes('__added')))
+		.map((it) => {
+			return { name: it, ...columns[it] };
+		});
+
+	const deletedIndexes = Object.fromEntries(
+		Object.entries(table.indexes__deleted || {})
+			.concat(
+				Object.entries(table.indexes || {}).filter((it) => it[0].includes('__deleted')),
+			)
+			.map((entry) => [entry[0].replace('__deleted', ''), entry[1]]),
+	);
+
+	const addedIndexes = Object.fromEntries(
+		Object.entries(table.indexes__added || {})
+			.concat(
+				Object.entries(table.indexes || {}).filter((it) => it[0].includes('__added')),
+			)
+			.map((entry) => [entry[0].replace('__added', ''), entry[1]]),
+	);
+
+	const alteredIndexes = Object.fromEntries(
+		Object.entries(table.indexes || {}).filter((it) => {
+			return !it[0].endsWith('__deleted') && !it[0].endsWith('__added');
+		}),
+	);
+
+	const deletedPolicies = Object.fromEntries(
+		Object.entries(table.policies__deleted || {})
+			.concat(
+				Object.entries(table.policies || {}).filter((it) => it[0].includes('__deleted')),
+			)
+			.map((entry) => [entry[0].replace('__deleted', ''), entry[1]]),
+	);
+
+	const addedPolicies = Object.fromEntries(
+		Object.entries(table.policies__added || {})
+			.concat(
+				Object.entries(table.policies || {}).filter((it) => it[0].includes('__added')),
+			)
+			.map((entry) => [entry[0].replace('__added', ''), entry[1]]),
+	);
+
+	const alteredPolicies = Object.fromEntries(
+		Object.entries(table.policies || {}).filter((it) => {
+			return !it[0].endsWith('__deleted') && !it[0].endsWith('__added');
+		}),
+	);
+
+	const deletedForeignKeys = Object.fromEntries(
+		Object.entries(table.foreignKeys__deleted || {})
+			.concat(
+				Object.entries(table.foreignKeys || {}).filter((it) => it[0].includes('__deleted')),
+			)
+			.map((entry) => [entry[0].replace('__deleted', ''), entry[1]]),
+	);
+
+	const addedForeignKeys = Object.fromEntries(
+		Object.entries(table.foreignKeys__added || {})
+			.concat(
+				Object.entries(table.foreignKeys || {}).filter((it) => it[0].includes('__added')),
+			)
+			.map((entry) => [entry[0].replace('__added', ''), entry[1]]),
+	);
+
+	const alteredForeignKeys = Object.fromEntries(
+		Object.entries(table.foreignKeys || {})
+			.filter(
+				(it) => !it[0].endsWith('__added') && !it[0].endsWith('__deleted'),
+			)
+			.map((entry) => [entry[0], entry[1]]),
+	);
+
+	const addedCompositePKs = Object.fromEntries(
+		Object.entries(table.compositePrimaryKeys || {}).filter((it) => {
+			return it[0].endsWith('__added');
+		}),
+	);
+
+	const deletedCompositePKs = Object.fromEntries(
+		Object.entries(table.compositePrimaryKeys || {}).filter((it) => {
+			return it[0].endsWith('__deleted');
+		}),
+	);
+
+	const alteredCompositePKs = Object.fromEntries(
+		Object.entries(table.compositePrimaryKeys || {}).filter((it) => {
+			return !it[0].endsWith('__deleted') && !it[0].endsWith('__added');
+		}),
+	);
+
+	const addedUniqueConstraints = Object.fromEntries(
+		Object.entries(table.uniqueConstraints || {}).filter((it) => {
+			return it[0].endsWith('__added');
+		}),
+	);
+
+	const deletedUniqueConstraints = Object.fromEntries(
+		Object.entries(table.uniqueConstraints || {}).filter((it) => {
+			return it[0].endsWith('__deleted');
+		}),
+	);
+
+	const alteredUniqueConstraints = Object.fromEntries(
+		Object.entries(table.uniqueConstraints || {}).filter((it) => {
+			return !it[0].endsWith('__deleted') && !it[0].endsWith('__added');
+		}),
+	);
+
+	const addedCheckConstraints = Object.fromEntries(
+		Object.entries(table.checkConstraints || {}).filter((it) => {
+			return it[0].endsWith('__added');
+		}),
+	);
+
+	const deletedCheckConstraints = Object.fromEntries(
+		Object.entries(table.checkConstraints || {}).filter((it) => {
+			return it[0].endsWith('__deleted');
+		}),
+	);
+
+	const alteredCheckConstraints = Object.fromEntries(
+		Object.entries(table.checkConstraints || {}).filter((it) => {
+			return !it[0].endsWith('__deleted') && !it[0].endsWith('__added');
+		}),
+	);
+
+	const mappedAltered = altered.map((it) => alternationsInColumn(it)).filter(Boolean);
+
+	return {
+		name: table.name,
+		schema: table.schema || '',
+		altered: mappedAltered,
+		addedIndexes,
+		deletedIndexes,
+		alteredIndexes,
+		addedForeignKeys,
+		deletedForeignKeys,
+		alteredForeignKeys,
+		addedCompositePKs,
+		deletedCompositePKs,
+		alteredCompositePKs,
+		addedUniqueConstraints,
+		deletedUniqueConstraints,
+		alteredUniqueConstraints,
+		deletedPolicies,
+		addedPolicies,
+		alteredPolicies,
+		addedCheckConstraints,
+		deletedCheckConstraints,
+		alteredCheckConstraints,
+	};
+};
+
+const alternationsInColumn = (column) => {
+	const altered = [column];
+
+	const result = altered
+		.filter((it) => {
+			if ('type' in it && it.type.__old.replace(' (', '(') === it.type.__new.replace(' (', '(')) {
+				return false;
+			}
+			return true;
+		})
+		.map((it) => {
+			if (typeof it.name !== 'string' && '__old' in it.name) {
+				// rename
+				return {
+					...it,
+					name: { type: 'changed', old: it.name.__old, new: it.name.__new },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('type' in it) {
+				// type change
+				return {
+					...it,
+					type: { type: 'changed', old: it.type.__old, new: it.type.__new },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('default' in it) {
+				return {
+					...it,
+					default: {
+						type: 'changed',
+						old: it.default.__old,
+						new: it.default.__new,
+					},
+				};
+			}
+			if ('default__added' in it) {
+				const { default__added, ...others } = it;
+				return {
+					...others,
+					default: { type: 'added', value: it.default__added },
+				};
+			}
+			if ('default__deleted' in it) {
+				const { default__deleted, ...others } = it;
+				return {
+					...others,
+					default: { type: 'deleted', value: it.default__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('generated' in it) {
+				if ('as' in it.generated && 'type' in it.generated) {
+					return {
+						...it,
+						generated: {
+							type: 'changed',
+							old: { as: it.generated.as.__old, type: it.generated.type.__old },
+							new: { as: it.generated.as.__new, type: it.generated.type.__new },
+						},
+					};
+				} else if ('as' in it.generated) {
+					return {
+						...it,
+						generated: {
+							type: 'changed',
+							old: { as: it.generated.as.__old },
+							new: { as: it.generated.as.__new },
+						},
+					};
+				} else {
+					return {
+						...it,
+						generated: {
+							type: 'changed',
+							old: { as: it.generated.type.__old },
+							new: { as: it.generated.type.__new },
+						},
+					};
+				}
+			}
+			if ('generated__added' in it) {
+				const { generated__added, ...others } = it;
+				return {
+					...others,
+					generated: { type: 'added', value: it.generated__added },
+				};
+			}
+			if ('generated__deleted' in it) {
+				const { generated__deleted, ...others } = it;
+				return {
+					...others,
+					generated: { type: 'deleted', value: it.generated__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('identity' in it) {
+				return {
+					...it,
+					identity: {
+						type: 'changed',
+						old: it.identity.__old,
+						new: it.identity.__new,
+					},
+				};
+			}
+			if ('identity__added' in it) {
+				const { identity__added, ...others } = it;
+				return {
+					...others,
+					identity: { type: 'added', value: it.identity__added },
+				};
+			}
+			if ('identity__deleted' in it) {
+				const { identity__deleted, ...others } = it;
+				return {
+					...others,
+					identity: { type: 'deleted', value: it.identity__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('notNull' in it) {
+				return {
+					...it,
+					notNull: {
+						type: 'changed',
+						old: it.notNull.__old,
+						new: it.notNull.__new,
+					},
+				};
+			}
+			if ('notNull__added' in it) {
+				const { notNull__added, ...others } = it;
+				return {
+					...others,
+					notNull: { type: 'added', value: it.notNull__added },
+				};
+			}
+			if ('notNull__deleted' in it) {
+				const { notNull__deleted, ...others } = it;
+				return {
+					...others,
+					notNull: { type: 'deleted', value: it.notNull__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('primaryKey' in it) {
+				return {
+					...it,
+					primaryKey: {
+						type: 'changed',
+						old: it.primaryKey.__old,
+						new: it.primaryKey.__new,
+					},
+				};
+			}
+			if ('primaryKey__added' in it) {
+				const { notNull__added, ...others } = it;
+				return {
+					...others,
+					primaryKey: { type: 'added', value: it.primaryKey__added },
+				};
+			}
+			if ('primaryKey__deleted' in it) {
+				const { notNull__deleted, ...others } = it;
+				return {
+					...others,
+					primaryKey: { type: 'deleted', value: it.primaryKey__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('typeSchema' in it) {
+				return {
+					...it,
+					typeSchema: {
+						type: 'changed',
+						old: it.typeSchema.__old,
+						new: it.typeSchema.__new,
+					},
+				};
+			}
+			if ('typeSchema__added' in it) {
+				const { typeSchema__added, ...others } = it;
+				return {
+					...others,
+					typeSchema: { type: 'added', value: it.typeSchema__added },
+				};
+			}
+			if ('typeSchema__deleted' in it) {
+				const { typeSchema__deleted, ...others } = it;
+				return {
+					...others,
+					typeSchema: { type: 'deleted', value: it.typeSchema__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('onUpdate' in it) {
+				return {
+					...it,
+					onUpdate: {
+						type: 'changed',
+						old: it.onUpdate.__old,
+						new: it.onUpdate.__new,
+					},
+				};
+			}
+			if ('onUpdate__added' in it) {
+				const { onUpdate__added, ...others } = it;
+				return {
+					...others,
+					onUpdate: { type: 'added', value: it.onUpdate__added },
+				};
+			}
+			if ('onUpdate__deleted' in it) {
+				const { onUpdate__deleted, ...others } = it;
+				return {
+					...others,
+					onUpdate: { type: 'deleted', value: it.onUpdate__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('autoincrement' in it) {
+				return {
+					...it,
+					autoincrement: {
+						type: 'changed',
+						old: it.autoincrement.__old,
+						new: it.autoincrement.__new,
+					},
+				};
+			}
+			if ('autoincrement__added' in it) {
+				const { autoincrement__added, ...others } = it;
+				return {
+					...others,
+					autoincrement: { type: 'added', value: it.autoincrement__added },
+				};
+			}
+			if ('autoincrement__deleted' in it) {
+				const { autoincrement__deleted, ...others } = it;
+				return {
+					...others,
+					autoincrement: { type: 'deleted', value: it.autoincrement__deleted },
+				};
+			}
+			return it;
+		})
+		.map((it) => {
+			if ('' in it) {
+				return {
+					...it,
+					autoincrement: {
+						type: 'changed',
+						old: it.autoincrement.__old,
+						new: it.autoincrement.__new,
+					},
+				};
+			}
+			if ('autoincrement__added' in it) {
+				const { autoincrement__added, ...others } = it;
+				return {
+					...others,
+					autoincrement: { type: 'added', value: it.autoincrement__added },
+				};
+			}
+			if ('autoincrement__deleted' in it) {
+				const { autoincrement__deleted, ...others } = it;
+				return {
+					...others,
+					autoincrement: { type: 'deleted', value: it.autoincrement__deleted },
+				};
+			}
+			return it;
+		})
+		.filter(Boolean);
+
+	return result[0];
+};