@prisma/orm-target-sqlite 8.0.0-rc.22-dev.7 → 8.0.0-rc.22-dev.9

package/dist/{op-factory-call-BQYECylm-K7S_xgRS.mjs → op-factory-call-Dxsyn5gF-CvHmM-h_.mjs}

@@ -7,16 +7,17 @@ import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault, opaqueSql } fro
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
 import "@prisma/orm-family-sql/contract/data-type";
 import { type } from "arktype";
+import { CliStructuredError } from "@prisma/orm-framework/errors/control";
 import { expectAbsent, expectPresent, issueOutcome } from "@prisma/orm-framework/components/control";
-import { checkSqlExpressionText, convertedColumnMeta, createSqlTextSources, encodeStoredValue, isUnfilledSlot, requiredColumnMeta, rowsHoldingValueMeta, slotSource, sqlOfSlot } from "@prisma/orm-family-sql/family/control";
+import { UnfilledValue, checkSqlExpressionText, convertedColumnMeta, createSqlTextSources, encodeStoredValue, fillKeyProblem, fillValueProblem, isUnfilledSlot, keyPathOf, parseJsonPath, requiredColumnMeta, rowsHoldingValueMeta, slotSource, sqlOfSlot } from "@prisma/orm-family-sql/family/control";
 import { RelationalSchemaNodeKind, sqlColumnTypesEqual } from "@prisma/orm-family-sql/schema-ir/types";
-import { errorMigrationOperationOptionRemoved, unfilledPlaceholderOperation } from "@prisma/orm-framework/errors/migration";
+import { errorMigrationOperationOptionRemoved, errorUnfilledPlaceholder, unfilledPlaceholderOperation } from "@prisma/orm-framework/errors/migration";
 import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
 import { TsExpression, jsonToTsSource, tsArraySource, tsObjectSource, tsQuotedTextSource } from "@prisma/orm-framework/ts-render";
-//#region ../../../3-targets/sqlite/1-target/dist/op-factory-call-BQYECylm.mjs
+//#region ../../../3-targets/sqlite/1-target/dist/op-factory-call-Dxsyn5gF.mjs
 function foldAsciiLetters(identifier) {
 	return identifier.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
 }
@@ -208,6 +209,130 @@ async function renameColumn(tableName, fromName, toName, lowerer) {
 		postcheck: [step(`verify column "${toName}" exists on "${tableName}"`, toPresent.sql, toPresent.params, expectPresent(`column "${toName}" on "${tableName}"`)), step(`verify column "${fromName}" no longer exists on "${tableName}"`, fromAbsent.sql, fromAbsent.params, expectAbsent(`column "${fromName}" on "${tableName}"`))]
 	};
 }
+/** The SQLite JSON path of member `name`, as an SQL string literal. */
+function memberPath(name) {
+	return `'${escapeLiteral(`$.${JSON.stringify(name)}`)}'`;
+}
+function child(value, depth) {
+	return `(${value} -> e${depth}.fullkey)`;
+}
+/**
+* The children of a list or an object rewritten one by one, keeping their order; `kept` filters
+* them. Any other value is left as it is.
+*/
+function rewrittenChildren(value, depth, rewrite, kept) {
+	const e = `e${depth}`;
+	const each = `FROM json_each(${value}) AS ${e}${kept === void 0 ? "" : ` WHERE ${kept(child(value, depth))}`}`;
+	const rewritten = `json(${rewrite(child(value, depth))})`;
+	return `CASE json_type(${value}) WHEN 'array' THEN (SELECT json_group_array(${rewritten} ORDER BY ${e}.key) ${each}) WHEN 'object' THEN (SELECT json_group_object(${e}.key, ${rewritten} ORDER BY ${e}.id) ${each}) ELSE ${value} END`;
+}
+/** Whether `value` is a list or an object with a child that passes `test`. */
+function someChild(value, depth, test) {
+	return `(json_type(${value}) IN ('array', 'object') AND EXISTS (SELECT 1 FROM json_each(${value}) AS e${depth} WHERE ${test(child(value, depth))}))`;
+}
+/**
+* The JSON text that rewrites `value` along `steps` with `leaf`. A member step that meets no object
+* with the member, or a wildcard step that meets neither a list nor an object, leaves the value as
+* it is.
+*/
+function jsonRewrite(value, steps, leaf, depth = 0) {
+	const [first, ...rest] = steps;
+	if (first === void 0) return leaf(value, depth);
+	if (first.kind === "member") {
+		const member = memberPath(first.name);
+		return `CASE WHEN json_type(${value}) = 'object' AND json_type(${value}, ${member}) IS NOT NULL THEN json_set(${value}, ${member}, json(${jsonRewrite(`(${value} -> ${member})`, rest, leaf, depth)})) ELSE ${value} END`;
+	}
+	return rewrittenChildren(value, depth, (c) => jsonRewrite(c, rest, leaf, depth + 1));
+}
+/**
+* Whether the JSON text `value` holds, at the end of `steps`, a value that passes `test`. Each step
+* tests the type of what it reads first, so a SQL `NULL`, a JSON `null`, a missing member, a value
+* of another type, or a `null` element or member value never fails the match.
+*/
+function jsonMatches(value, steps, test, depth = 0) {
+	const [first, ...rest] = steps;
+	if (first === void 0) return test(value, depth);
+	if (first.kind === "member") {
+		const member = memberPath(first.name);
+		return `(json_type(${value}) = 'object' AND json_type(${value}, ${member}) IS NOT NULL AND ${jsonMatches(`(${value} -> ${member})`, rest, test, depth)})`;
+	}
+	return someChild(value, depth, (c) => jsonMatches(c, rest, test, depth + 1));
+}
+/** Whether the JSON text `value` is an object that has member `name`. */
+function hasMember(value, name) {
+	return `(json_type(${value}) = 'object' AND json_type(${value}, ${memberPath(name)}) IS NOT NULL)`;
+}
+function at(keyPath) {
+	return `at path ${JSON.stringify(keyPath.objectsText)}`;
+}
+/** Where in a column a key operation acts, as its label and step descriptions write it. */
+function keyPlace(keyPath, tableName, columnName) {
+	return `${at(keyPath)} in column "${columnName}" of "${tableName}"`;
+}
+function noRowWhere(tableName, condition) {
+	return `SELECT NOT EXISTS (SELECT 1 FROM ${quoteIdentifier(tableName)} WHERE ${condition}) AS result`;
+}
+function objectsMatch(columnName, keyPath, test) {
+	return jsonMatches(quoteIdentifier(columnName), keyPath.objects, test);
+}
+function renameStoredKey(tableName, columnName, keyPath, to) {
+	const column = quoteIdentifier(columnName);
+	const from = memberPath(keyPath.key);
+	const renamed = jsonRewrite(column, keyPath.objects, (object) => `CASE WHEN ${hasMember(object, keyPath.key)} THEN json_set(json_remove(${object}, ${from}), ${memberPath(to)}, json(${object} -> ${from})) ELSE ${object} END`);
+	const holdsKey = objectsMatch(columnName, keyPath, (object) => hasMember(object, keyPath.key));
+	const place = keyPlace(keyPath, tableName, columnName);
+	return {
+		id: `renameStoredKey.${tableName}.${columnName}.${keyPath.path.text}`,
+		label: `Rename key "${keyPath.key}" to "${to}" ${place}`,
+		operationClass: "widening",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: [step(`ensure no object ${place} has both key "${keyPath.key}" and key "${to}"; remove one of the two keys from those objects`, noRowWhere(tableName, objectsMatch(columnName, keyPath, (object) => `(${hasMember(object, keyPath.key)} AND ${hasMember(object, to)})`)))],
+		execute: [step(`rename key "${keyPath.key}" to "${to}" ${place}`, `UPDATE ${quoteIdentifier(tableName)} SET ${column} = ${renamed} WHERE ${holdsKey}`)],
+		postcheck: [step(`verify no object ${place} has key "${keyPath.key}"`, noRowWhere(tableName, holdsKey))]
+	};
+}
+function removeStoredKey(tableName, columnName, keyPath) {
+	const column = quoteIdentifier(columnName);
+	const removed = jsonRewrite(column, keyPath.objects, (object) => `CASE WHEN ${hasMember(object, keyPath.key)} THEN json_remove(${object}, ${memberPath(keyPath.key)}) ELSE ${object} END`);
+	const holdsKey = objectsMatch(columnName, keyPath, (object) => hasMember(object, keyPath.key));
+	const place = keyPlace(keyPath, tableName, columnName);
+	return {
+		id: `removeStoredKey.${tableName}.${columnName}.${keyPath.path.text}`,
+		label: `Remove key "${keyPath.key}" ${place}`,
+		operationClass: "destructive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: [],
+		execute: [step(`remove key "${keyPath.key}" ${place}`, `UPDATE ${quoteIdentifier(tableName)} SET ${column} = ${removed} WHERE ${holdsKey}`)],
+		postcheck: [step(`verify no object ${place} has key "${keyPath.key}"`, noRowWhere(tableName, holdsKey))]
+	};
+}
+/** `value` is the JSON text of the value the key takes, passed as a parameter. A key that holds JSON `null` is filled too, as a member that becomes required needs. */
+function fillStoredKey(tableName, columnName, keyPath, value) {
+	const column = quoteIdentifier(columnName);
+	const member = memberPath(keyPath.key);
+	const lacks = (object) => `(json_type(${object}) = 'object' AND coalesce(json_type(${object}, ${member}), 'null') = 'null')`;
+	const filled = jsonRewrite(column, keyPath.objects, (object) => `CASE WHEN ${lacks(object)} THEN json_set(${object}, ${member}, json(?1)) ELSE ${object} END`);
+	const lacksKey = objectsMatch(columnName, keyPath, lacks);
+	const place = keyPlace(keyPath, tableName, columnName);
+	return {
+		id: `fillStoredKey.${tableName}.${columnName}.${keyPath.path.text}`,
+		label: `Fill key "${keyPath.key}" ${place}`,
+		operationClass: "widening",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: [],
+		execute: [step(`fill key "${keyPath.key}" ${place} in every object that lacks it or holds JSON null there`, `UPDATE ${quoteIdentifier(tableName)} SET ${column} = ${filled} WHERE ${lacksKey}`, [value])],
+		postcheck: [step(`verify every object ${place} has key "${keyPath.key}"`, noRowWhere(tableName, lacksKey))]
+	};
+}
 /** A stored value as operation ids, labels and step descriptions write it. */
 function storedValueText(value) {
 	return JSON.stringify(value);
@@ -246,12 +371,140 @@ function removeStoredValue(tableName, columnName, value, mark) {
 		},
 		precheck: [{
 			...columnTakesNullOrValueAbsentCheck(tableName, columnName, value, takesNull),
-			...mark === void 0 ? {} : { meta: rowsHoldingValueMeta(mark) }
+			...mark === void 0 ? {} : { meta: rowsHoldingValueMeta({
+				...mark,
+				table: tableName,
+				column: columnName,
+				storedValue: value
+			}) }
 		}],
 		execute: [step(`remove value ${storedValueText(value)} from column "${columnName}"`, `UPDATE ${quoteIdentifier(tableName)} SET ${column} = NULL WHERE ${column} = ?1`, [value])],
 		postcheck: [valueAbsentCheck(tableName, columnName, value)]
 	};
 }
+function cascadeStep(tableName, columnName, value, cascade) {
+	const referenced = cascade.columns.map((column, index) => {
+		const reference = cascade.references[index];
+		if (reference === void 0) throw new InternalError(`Cascade of table "${cascade.table}" has no reference for column "${column}"`);
+		return `${quoteIdentifier(tableName)}.${quoteIdentifier(reference)} = ${quoteIdentifier(cascade.table)}.${quoteIdentifier(column)}`;
+	}).join(" AND ");
+	return step(`delete the rows of "${cascade.table}" whose row of "${tableName}" holds value ${storedValueText(value)} in column "${columnName}", as their foreign key's cascade would`, `DELETE FROM ${quoteIdentifier(cascade.table)} WHERE EXISTS (SELECT 1 FROM ${quoteIdentifier(tableName)} WHERE ${quoteIdentifier(tableName)}.${quoteIdentifier(columnName)} = ?1 AND ${referenced})`, [value]);
+}
+/** The label of a `deleteRows` operation, which names each `cascade` table whose rows it deletes too. */
+function deleteRowsLabel(tableName, columnName, value, cascade) {
+	const rows = `Delete the rows of "${tableName}" that hold value ${storedValueText(value)} in column "${columnName}"`;
+	if (cascade.length === 0) return rows;
+	return `${rows}, and the rows of ${cascade.map(({ table }) => `"${table}"`).join(", ")} that reference them`;
+}
+/** Deletes the rows that hold `value`, after the rows of each `cascade` table that reference them: the runner turns foreign keys off, so no declared cascade runs. */
+function deleteRows(tableName, columnName, value, cascade) {
+	return {
+		id: `deleteRows.${tableName}.${columnName}.${idText(value)}`,
+		label: deleteRowsLabel(tableName, columnName, value, cascade),
+		operationClass: "destructive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: [],
+		execute: [...cascade.map((foreignKey) => cascadeStep(tableName, columnName, value, foreignKey)), step(`delete the rows of "${tableName}" that hold value ${storedValueText(value)} in column "${columnName}"`, `DELETE FROM ${quoteIdentifier(tableName)} WHERE ${quoteIdentifier(columnName)} = ?1`, [value])],
+		postcheck: [valueAbsentCheck(tableName, columnName, value)]
+	};
+}
+function pathParts(path) {
+	const last = path.steps.at(-1);
+	if (last === void 0) throw new InternalError("A stored value path ends at a selector");
+	return {
+		reach: path.steps.slice(0, -1),
+		last
+	};
+}
+/** Whether the JSON text `value` is the JSON form of `stored`, bound as parameter `param`. */
+function isStoredValue(value, stored, param) {
+	return `(json_type(${value}) ${typeof stored === "string" ? `= 'text'` : `IN ('integer', 'real')`} AND (${value} ->> '$') = ${param})`;
+}
+function memberHolds(object, name, stored, param) {
+	return `(json_type(${object}) = 'object' AND ${isStoredValue(`(${object} -> ${memberPath(name)})`, stored, param)})`;
+}
+/** Whether the JSON text of `column` holds `stored`, bound as parameter `param`, at the end of `path`. */
+function holdsAtPath(column, path, stored, param) {
+	const { reach, last } = pathParts(path);
+	return jsonMatches(column, reach, (value, depth) => last.kind === "member" ? memberHolds(value, last.name, stored, param) : someChild(value, depth, (child) => isStoredValue(child, stored, param)));
+}
+/** The JSON text that sets the value at the end of `path` that equals `?1` to `replacement`, or, when `replacement` is undefined, removes it from a list or removes the member of an object that holds it. */
+function rewriteAtPath(column, path, stored, replacement) {
+	const { reach, last } = pathParts(path);
+	if (last.kind === "member") return jsonRewrite(column, reach, (object) => `CASE WHEN ${memberHolds(object, last.name, stored, "?1")} THEN json_set(${object}, ${memberPath(last.name)}, ${replacement ?? "json('null')"}) ELSE ${object} END`);
+	return jsonRewrite(column, reach, (container, depth) => replacement === void 0 ? rewrittenChildren(container, depth, (child) => child, (child) => `NOT ${isStoredValue(child, stored, "?1")}`) : rewrittenChildren(container, depth, (child) => `CASE WHEN ${isStoredValue(child, stored, "?1")} THEN json_quote(${replacement}) ELSE ${child} END`));
+}
+function atPath(path, tableName, columnName) {
+	return `at path ${JSON.stringify(path.text)} in column "${columnName}" of "${tableName}"`;
+}
+function valueAbsentAtPathCheck(tableName, columnName, value, path) {
+	return step(`verify no row holds value ${storedValueText(value)} ${atPath(path, tableName, columnName)}`, `SELECT NOT EXISTS (SELECT 1 FROM ${quoteIdentifier(tableName)} WHERE ${holdsAtPath(quoteIdentifier(columnName), path, value, "?1")}) AS result`, [value]);
+}
+/** The condition and parameters that find the rows of a column that hold a stored value, at `path` inside its JSON when it is given. */
+function holdingStoredValue(columnName, storedValue, path) {
+	const column = quoteIdentifier(columnName);
+	if (path === void 0) return {
+		condition: `${column} = ?1`,
+		params: [storedValue]
+	};
+	const parsed = parseJsonPath(path);
+	if (!parsed.ok) throw new InternalError(`A stored value path is a JSON path: ${parsed.failure}`);
+	return {
+		condition: holdsAtPath(column, parsed.value, storedValue, "?1"),
+		params: [storedValue]
+	};
+}
+function replaceStoredValueAtPath(tableName, columnName, from, to, path) {
+	const column = quoteIdentifier(columnName);
+	const place = atPath(path, tableName, columnName);
+	return {
+		id: `replaceStoredValue.${tableName}.${columnName}.${path.text}.${idText(from)}`,
+		label: `Replace value ${storedValueText(from)} with ${storedValueText(to)} ${place}`,
+		operationClass: "widening",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: [],
+		execute: [step(`replace value ${storedValueText(from)} with ${storedValueText(to)} ${place}`, `UPDATE ${quoteIdentifier(tableName)} SET ${column} = ${rewriteAtPath(column, path, from, "?2")} WHERE ${holdsAtPath(column, path, from, "?1")}`, [from, to])],
+		postcheck: [valueAbsentAtPathCheck(tableName, columnName, from, path)]
+	};
+}
+/**
+* Removes a stored value inside JSON: takes it out of a list, or removes its member from an object,
+* when `path` ends at a wildcard, else sets the member to JSON `null`. When the member takes no
+* null, the check fails while a row holds the value.
+*/
+function removeStoredValueAtPath(tableName, columnName, value, path, nullable, mark) {
+	const column = quoteIdentifier(columnName);
+	const place = atPath(path, tableName, columnName);
+	const holds = holdsAtPath(column, path, value, "?1");
+	const required = pathParts(path).last.kind === "member" && !nullable;
+	return {
+		id: `removeStoredValue.${tableName}.${columnName}.${path.text}.${idText(value)}`,
+		label: `Remove value ${storedValueText(value)} ${place}`,
+		operationClass: "destructive",
+		target: {
+			id: "sqlite",
+			details: buildTargetDetails("column", columnName, tableName)
+		},
+		precheck: required ? [{
+			...step(`ensure no row holds ${storedValueText(value)} ${place}, a member that takes no null`, `SELECT NOT EXISTS (SELECT 1 FROM ${quoteIdentifier(tableName)} WHERE ${holds}) AS result`, [value]),
+			...mark === void 0 ? {} : { meta: rowsHoldingValueMeta({
+				...mark,
+				table: tableName,
+				column: columnName,
+				storedValue: value,
+				path: path.text
+			}) }
+		}] : [],
+		execute: [step(`remove value ${storedValueText(value)} ${place}`, `UPDATE ${quoteIdentifier(tableName)} SET ${column} = ${rewriteAtPath(column, path, value, void 0)} WHERE ${holds}`, [value])],
+		postcheck: [valueAbsentAtPathCheck(tableName, columnName, value, path)]
+	};
+}
 function buildCreateIndexSql(tableName, indexName, columns, unique = false) {
 	return `CREATE ${unique ? "UNIQUE " : ""}INDEX ${quoteIdentifier(indexName)} ON ${quoteIdentifier(tableName)} (${columns.map(quoteIdentifier).join(", ")})`;
 }
@@ -842,7 +1095,7 @@ var DropTableCall = class extends SqliteOpFactoryCallNode {
 	constructor(tableName) {
 		super();
 		this.tableName = tableName;
-		this.label = `Drop table ${tableName}`;
+		this.label = `Drop table "${tableName}"`;
 		this.freeze();
 	}
 	async toOp(lowerer) {
@@ -855,7 +1108,7 @@ var DropTableCall = class extends SqliteOpFactoryCallNode {
 		const absent = await lowerer.lowerToExecuteRequest(checks.tableAbsent());
 		return {
 			id: `dropTable.${this.tableName}`,
-			label: `Drop table ${this.tableName}`,
+			label: `Drop table "${this.tableName}"`,
 			summary: `Drops table ${this.tableName} which is not in the contract`,
 			operationClass: "destructive",
 			target: {
@@ -1206,7 +1459,7 @@ var DropColumnCall = class extends SqliteOpFactoryCallNode {
 		super();
 		this.tableName = tableName;
 		this.columnName = columnName;
-		this.label = `Drop column ${columnName} on ${tableName}`;
+		this.label = `Drop column "${columnName}" from "${tableName}"`;
 		this.freeze();
 	}
 	async toOp(lowerer) {
@@ -1220,7 +1473,7 @@ var DropColumnCall = class extends SqliteOpFactoryCallNode {
 		const absent = await lowerer.lowerToExecuteRequest(checks.columnAbsent());
 		return {
 			id: `dropColumn.${this.tableName}.${this.columnName}`,
-			label: `Drop column ${this.columnName} on ${this.tableName}`,
+			label: `Drop column "${this.columnName}" from "${this.tableName}"`,
 			summary: `Drops column ${this.columnName} on ${this.tableName} which is not in the contract`,
 			operationClass: "destructive",
 			target: {
@@ -1335,15 +1588,34 @@ var DropIndexCall = class extends SqliteOpFactoryCallNode {
 		return [];
 	}
 };
-function replaceStoredValueSource(tableName, columnName, from, to, codec) {
+function replaceStoredValueSource(tableName, columnName, from, to, codec, path) {
 	return `this.replaceStoredValue({ ${[
 		`table: ${jsonToTsSource(tableName)}`,
 		`column: ${jsonToTsSource(columnName)}`,
+		...pathSource(path),
 		`from: ${from}`,
 		`to: ${to}`,
 		...codecRefSource(codec)
 	].join(", ")} })`;
 }
+function pathSource(path) {
+	return path === void 0 ? [] : [`path: ${jsonToTsSource(path.text)}`];
+}
+function storedValuePlace(path, tableName, columnName) {
+	return path === void 0 ? `in column "${columnName}" of "${tableName}"` : `at path ${JSON.stringify(path.text)} in column "${columnName}" of "${tableName}"`;
+}
+/**
+* The path a stored value call acts at inside JSON: it ends at a member name or at a list
+* wildcard, and the value is compared as a JSON value, so it takes no codec.
+*/
+function requireValuePath(path, codec, factory, tableName, columnName) {
+	if (path === void 0) return void 0;
+	const location = columnCallLocation(tableName, columnName);
+	const parsed = requirePath(path, factory, location);
+	if (parsed.steps.length === 0) refusedArgument(factory, location, "path", `path ${JSON.stringify(path)} does not end at a member name or a wildcard ([*] or .*)`);
+	if (codec !== void 0) refusedArgument(factory, location, "path", "path takes no codecRef: a value inside JSON is compared as a JSON value");
+	return parsed;
+}
 function codecRefSource(codec) {
 	return codec === void 0 ? [] : [`codecRef: ${jsonToTsSource(codec.codecRef)}`];
 }
@@ -1352,7 +1624,7 @@ function requireStoredValue(value, factory, tableName, columnName, argument) {
 	const got = value;
 	throw sqliteError("CONTRACT.ARGUMENT_INVALID", `${factory}({ table: ${jsonToTsSource(tableName)}, column: ${jsonToTsSource(columnName)} }): ${argument} must be a string or a number; got ${typeof got === "number" || got === void 0 ? String(got) : JSON.stringify(got)}`, { meta: { what: `${factory} ${argument}` } });
 }
-/** Changes one stored value of a column to another, in every row that holds it. */
+/** Changes one stored value of a column to another, in every row that holds it, or at a path inside the JSON of the column. */
 var ReplaceStoredValueCall = class extends SqliteOpFactoryCallNode {
 	factoryName = "replaceStoredValue";
 	operationClass = "widening";
@@ -1362,28 +1634,32 @@ var ReplaceStoredValueCall = class extends SqliteOpFactoryCallNode {
 	to;
 	/** The column's codec, which writes `from` and `to` as the database stores them. */
 	codec;
+	/** The path inside the column's JSON at which the value is replaced, compared as a JSON value. */
+	path;
 	label;
-	constructor(tableName, columnName, from, to, codec) {
+	constructor(tableName, columnName, from, to, codec, path) {
 		super();
 		this.codec = codec;
 		this.tableName = tableName;
 		this.columnName = columnName;
 		this.from = requireStoredValue(from, this.factoryName, tableName, columnName, "from");
 		this.to = requireStoredValue(to, this.factoryName, tableName, columnName, "to");
-		this.label = `Replace value ${storedValueText(from)} with ${storedValueText(to)} in column "${columnName}" of "${tableName}"`;
+		this.path = requireValuePath(path, codec, this.factoryName, tableName, columnName);
+		this.label = `Replace value ${storedValueText(from)} with ${storedValueText(to)} ${storedValuePlace(this.path, tableName, columnName)}`;
 		this.freeze();
 	}
 	async toOp() {
+		if (this.path !== void 0) return replaceStoredValueAtPath(this.tableName, this.columnName, this.from, this.to, this.path);
 		return replaceStoredValue(this.tableName, this.columnName, await encodeStoredValue(this.from, this.codec), await encodeStoredValue(this.to, this.codec));
 	}
 	renderTypeScript() {
-		return replaceStoredValueSource(this.tableName, this.columnName, jsonToTsSource(this.from), jsonToTsSource(this.to), this.codec);
+		return replaceStoredValueSource(this.tableName, this.columnName, jsonToTsSource(this.from), jsonToTsSource(this.to), this.codec, this.path);
 	}
 	importRequirements() {
 		return [];
 	}
 };
-/** Removes one stored value of a column by setting it to NULL in every row that holds it. */
+/** Removes one stored value of a column by setting it to NULL in every row that holds it, or removes it at a path inside the JSON of the column. */
 var RemoveStoredValueCall = class extends SqliteOpFactoryCallNode {
 	factoryName = "removeStoredValue";
 	operationClass = "destructive";
@@ -1394,29 +1670,40 @@ var RemoveStoredValueCall = class extends SqliteOpFactoryCallNode {
 	codec;
 	/** The enum value whose stored value is removed, which the check that fails while rows of a required column hold it names. */
 	enumValue;
+	/** The path inside the column's JSON at which the value is removed, compared as a JSON value. */
+	path;
+	/** Whether the member at `path` takes JSON `null`; when it does not, the check fails while a row holds the value. */
+	nullable;
 	label;
-	constructor(tableName, columnName, value, codec, enumValue) {
+	constructor(tableName, columnName, value, codec, enumValue, path, nullable) {
 		super();
 		this.codec = codec;
 		this.enumValue = enumValue;
 		this.tableName = tableName;
 		this.columnName = columnName;
 		this.value = requireStoredValue(value, this.factoryName, tableName, columnName, "value");
-		this.label = `Remove value ${storedValueText(value)} from column "${columnName}" of "${tableName}"`;
+		this.path = requireValuePath(path, codec, this.factoryName, tableName, columnName);
+		if (nullable !== void 0 && this.path === void 0) refusedArgument(this.factoryName, columnCallLocation(tableName, columnName), "nullable", "nullable needs a path: a column says itself whether it takes NULL");
+		this.nullable = nullable === true;
+		this.label = `Remove value ${storedValueText(value)} ${this.path === void 0 ? `from column "${columnName}" of "${tableName}"` : storedValuePlace(this.path, tableName, columnName)}`;
 		this.freeze();
 	}
 	async toOp() {
-		return removeStoredValue(this.tableName, this.columnName, await encodeStoredValue(this.value, this.codec), this.enumValue === void 0 ? void 0 : {
+		const mark = this.enumValue === void 0 ? void 0 : {
 			enumValue: this.enumValue,
 			value: this.value,
 			...this.codec === void 0 ? {} : { codecRef: this.codec.codecRef }
-		});
+		};
+		if (this.path !== void 0) return removeStoredValueAtPath(this.tableName, this.columnName, this.value, this.path, this.nullable, mark);
+		return removeStoredValue(this.tableName, this.columnName, await encodeStoredValue(this.value, this.codec), mark);
 	}
 	renderTypeScript() {
 		return `this.removeStoredValue({ ${[
 			`table: ${jsonToTsSource(this.tableName)}`,
 			`column: ${jsonToTsSource(this.columnName)}`,
+			...pathSource(this.path),
 			`value: ${jsonToTsSource(this.value)}`,
+			...this.nullable ? ["nullable: true"] : [],
 			...codecRefSource(this.codec),
 			...this.enumValue === void 0 ? [] : [`enumValue: ${jsonToTsSource(this.enumValue)}`]
 		].join(", ")} })`;
@@ -1425,6 +1712,204 @@ var RemoveStoredValueCall = class extends SqliteOpFactoryCallNode {
 		return [];
 	}
 };
+/** Deletes the rows whose column holds one stored value. */
+var DeleteRowsCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "deleteRows";
+	operationClass = "destructive";
+	tableName;
+	columnName;
+	value;
+	/** The column's codec, which writes `value` as the database stores it. */
+	codec;
+	/** The tables whose rows reference the deleted rows through a foreign key that cascades, deleted first. */
+	cascade;
+	label;
+	constructor(tableName, columnName, value, codec, cascade = []) {
+		super();
+		this.codec = codec;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.value = requireStoredValue(value, this.factoryName, tableName, columnName, "value");
+		this.cascade = cascade.map((foreignKey) => requireCascade(foreignKey, this.factoryName, columnCallLocation(tableName, columnName)));
+		this.label = deleteRowsLabel(tableName, columnName, value, this.cascade);
+		this.freeze();
+	}
+	async toOp() {
+		return deleteRows(this.tableName, this.columnName, await encodeStoredValue(this.value, this.codec), this.cascade);
+	}
+	renderTypeScript() {
+		return `this.deleteRows({ ${[
+			`table: ${jsonToTsSource(this.tableName)}`,
+			`column: ${jsonToTsSource(this.columnName)}`,
+			`value: ${jsonToTsSource(this.value)}`,
+			...codecRefSource(this.codec),
+			...this.cascade.length === 0 ? [] : [`cascade: ${jsonToTsSource(this.cascade)}`]
+		].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+function requireCascade(foreignKey, factory, location) {
+	const { columns, references } = foreignKey;
+	return columns.length > 0 && columns.length === references.length ? {
+		table: foreignKey.table,
+		columns: [...columns],
+		references: [...references]
+	} : refusedArgument(factory, location, "cascade", `cascade of table ${JSON.stringify(foreignKey.table)} must name as many columns as references, and at least one`);
+}
+function columnCallLocation(tableName, columnName) {
+	return [`table: ${jsonToTsSource(tableName)}`, `column: ${jsonToTsSource(columnName)}`];
+}
+function refusedArgument(factory, location, argument, why) {
+	throw sqliteError("CONTRACT.ARGUMENT_INVALID", `${factory}({ ${location.join(", ")} }): ${why}`, { meta: { what: `${factory} ${argument}` } });
+}
+function requirePath(text, factory, location) {
+	const parsed = parseJsonPath(text);
+	return parsed.ok ? parsed.value : refusedArgument(factory, location, "path", parsed.failure);
+}
+function requireKeyPath(text, factory, location) {
+	return keyPathOf(requirePath(text, factory, location)) ?? refusedArgument(factory, location, "path", `path ${JSON.stringify(text)} does not end at a member name, the key the operation acts on`);
+}
+/** Renames the key at the end of a JSON path, in every object of a column the path reaches. */
+var RenameStoredKeyCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "renameStoredKey";
+	operationClass = "widening";
+	tableName;
+	columnName;
+	path;
+	to;
+	label;
+	constructor(tableName, columnName, path, to) {
+		super();
+		const location = columnCallLocation(tableName, columnName);
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.path = requireKeyPath(path, this.factoryName, location);
+		if (typeof to !== "string" || to === this.path.key) refusedArgument(this.factoryName, location, "to", `to must be a key other than ${JSON.stringify(this.path.key)}; got ${JSON.stringify(to)}`);
+		this.to = to;
+		this.label = `Rename key "${this.path.key}" to "${to}" ${keyPlace(this.path, tableName, columnName)}`;
+		this.freeze();
+	}
+	toOp() {
+		return renameStoredKey(this.tableName, this.columnName, this.path, this.to);
+	}
+	renderTypeScript() {
+		return `this.renameStoredKey({ ${[
+			...columnCallLocation(this.tableName, this.columnName),
+			`path: ${jsonToTsSource(this.path.path.text)}`,
+			`to: ${jsonToTsSource(this.to)}`
+		].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/** Removes the key at the end of a JSON path, from every object of a column the path reaches. */
+var RemoveStoredKeyCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "removeStoredKey";
+	operationClass = "destructive";
+	tableName;
+	columnName;
+	path;
+	label;
+	constructor(tableName, columnName, path) {
+		super();
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.path = requireKeyPath(path, this.factoryName, columnCallLocation(tableName, columnName));
+		this.label = `Remove key "${this.path.key}" ${keyPlace(this.path, tableName, columnName)}`;
+		this.freeze();
+	}
+	toOp() {
+		return removeStoredKey(this.tableName, this.columnName, this.path);
+	}
+	renderTypeScript() {
+		return `this.removeStoredKey({ ${[...columnCallLocation(this.tableName, this.columnName), `path: ${jsonToTsSource(this.path.path.text)}`].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+function requireJsonValue(value, factory, location) {
+	return JSON.stringify(value) === void 0 ? refusedArgument(factory, location, "value", "value must be a JSON value; got undefined") : value;
+}
+function requireFillValue(value, field, factory, location) {
+	const json = requireJsonValue(value, factory, location);
+	const problem = fillValueProblem(json, field);
+	return problem === void 0 ? json : refusedArgument(factory, location, "value", problem);
+}
+/**
+* The operation of a fill whose value is an unfilled placeholder: a promise that rejects with
+* `MIGRATION.UNFILLED_PLACEHOLDER`, whose meta names the operation it stands for, so that a plan can
+* list it before the user fills the value.
+*/
+function unfilledFillOperation(slot, standsFor) {
+	const unfilled = errorUnfilledPlaceholder(slot);
+	const operation = Promise.reject(new CliStructuredError(unfilled.code, unfilled.message, {
+		...ifDefined("why", unfilled.why),
+		...ifDefined("fix", unfilled.fix),
+		meta: {
+			slot,
+			operation: {
+				id: standsFor.id,
+				label: standsFor.label,
+				operationClass: standsFor.operationClass
+			}
+		}
+	}));
+	operation.catch(() => void 0);
+	return operation;
+}
+/**
+* Sets the key at the end of a JSON path to a value, in every object of a column the path reaches that lacks it or holds JSON `null` there. An unfilled value is a placeholder the user fills in `migration.ts`; until then the call lowers to no operation.
+*/
+var FillStoredKeyCall = class extends SqliteOpFactoryCallNode {
+	factoryName = "fillStoredKey";
+	operationClass = "widening";
+	tableName;
+	columnName;
+	path;
+	value;
+	/** The value object field the key holds, which must take `value`. */
+	field;
+	label;
+	constructor(tableName, columnName, path, value, field) {
+		super();
+		const location = columnCallLocation(tableName, columnName);
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.path = requireKeyPath(path, this.factoryName, location);
+		const keyProblem = fillKeyProblem({
+			key: this.path.key,
+			path: this.path.path.text
+		}, field);
+		if (keyProblem !== void 0) refusedArgument(this.factoryName, location, "field", keyProblem);
+		this.field = field;
+		this.value = value instanceof UnfilledValue ? value : requireFillValue(value, field, this.factoryName, location);
+		this.label = `Fill key "${this.path.key}" ${keyPlace(this.path, tableName, columnName)}`;
+		this.freeze();
+	}
+	toOp() {
+		if (this.value instanceof UnfilledValue) return unfilledFillOperation(this.value.slot, fillStoredKey(this.tableName, this.columnName, this.path, "null"));
+		return fillStoredKey(this.tableName, this.columnName, this.path, JSON.stringify(this.value));
+	}
+	renderTypeScript() {
+		const value = this.value instanceof UnfilledValue ? `placeholder(${jsonToTsSource(this.value.slot)})` : jsonToTsSource(this.value);
+		return `this.fillStoredKey({ ${[
+			...columnCallLocation(this.tableName, this.columnName),
+			`path: ${jsonToTsSource(this.path.path.text)}`,
+			`value: ${value}`,
+			...this.field === void 0 ? [] : [`field: ${jsonToTsSource(this.field.text)}`]
+		].join(", ")} })`;
+	}
+	importRequirements() {
+		return this.value instanceof UnfilledValue ? [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "placeholder"
+		}] : [];
+	}
+};
 /**
 * A planner-generated data-transform stub. The current default strategy
 * (`nullabilityTighteningBackfillStrategy`) emits one of these with a
@@ -1551,6 +2036,6 @@ function renderPostcheck(postcheck) {
 	}));
 }
 //#endregion
-export { sqliteDefaultToDdlColumnDefault as C, renameTableSteps as S, step as T, buildRecreateSummary as _, DropColumnCall as a, isSqliteOpFactoryCall as b, INLINE_AUTOINCREMENT_PRIMARY_KEY as c, RemoveStoredValueCall as d, RenameColumnCall as f, buildRecreatePostchecks as g, affinityStorageClasses as h, DataTransformCall as i, RawSqlCall as l, ReplaceStoredValueCall as m, CreateIndexCall as n, DropIndexCall as o, RenameTableCall as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RecreateTableCall as u, conversionCopyOf as v, sqliteIdentifiersCollide as w, rebuiltTableName as x, indexReplacementCalls as y };
+export { step as A, holdingStoredValue as C, renameTableSteps as D, rebuiltTableName as E, sqliteDefaultToDdlColumnDefault as O, conversionCopyOf as S, isSqliteOpFactoryCall as T, RenameTableCall as _, DeleteRowsCall as a, buildRecreatePostchecks as b, DropTableCall as c, RawSqlCall as d, RecreateTableCall as f, RenameStoredKeyCall as g, RenameColumnCall as h, DataTransformCall as i, sqliteIdentifiersCollide as k, FillStoredKeyCall as l, RemoveStoredValueCall as m, CreateIndexCall as n, DropColumnCall as o, RemoveStoredKeyCall as p, CreateTableCall as r, DropIndexCall as s, AddColumnCall as t, INLINE_AUTOINCREMENT_PRIMARY_KEY as u, ReplaceStoredValueCall as v, indexReplacementCalls as w, buildRecreateSummary as x, affinityStorageClasses as y };
 
-//# sourceMappingURL=op-factory-call-BQYECylm-K7S_xgRS.mjs.map
+//# sourceMappingURL=op-factory-call-Dxsyn5gF-CvHmM-h_.mjs.map