@prisma-next/family-sql 0.9.0 → 0.10.0

package/dist/control.d.mts

@@ -1,4 +1,4 @@
-import { A as SqlPlannerConflictKind, C as SqlMigrationRunnerExecuteCallbacks, D as SqlMigrationRunnerSuccessValue, E as SqlMigrationRunnerResult, F as StorageTypePlanResult, I as SqlControlFamilyInstance, M as SqlPlannerFailureResult, N as SqlPlannerResult, O as SqlPlanTargetDetails, P as SqlPlannerSuccessResult, S as SqlMigrationRunnerErrorCode, T as SqlMigrationRunnerFailure, _ as SqlMigrationPlanOperationStep, a as FieldEvent, b as SqlMigrationPlannerPlanOptions, c as MultiSpaceRunnerResult, d as SqlControlAdapterDescriptor, f as SqlControlExtensionDescriptor, g as SqlMigrationPlanOperation, h as SqlMigrationPlanContractInfo, i as ExpandNativeTypeInput, j as SqlPlannerConflictLocation, k as SqlPlannerConflict, l as MultiSpaceRunnerSuccessValue, m as SqlMigrationPlan, n as CodecControlHooks, o as FieldEventContext, p as SqlControlTargetDescriptor, r as CreateSqlMigrationPlanOptions, s as MultiSpaceRunnerFailure, t as AnyRecord, u as ResolveIdentityValueInput, v as SqlMigrationPlanOperationTarget, w as SqlMigrationRunnerExecuteOptions, x as SqlMigrationRunner, y as SqlMigrationPlanner } from "./types-DMINfGUO.mjs";
+import { A as SqlPlannerConflictKind, C as SqlMigrationRunnerExecuteCallbacks, D as SqlMigrationRunnerSuccessValue, E as SqlMigrationRunnerResult, F as StorageTypePlanResult, I as SqlControlFamilyInstance, M as SqlPlannerFailureResult, N as SqlPlannerResult, O as SqlPlanTargetDetails, P as SqlPlannerSuccessResult, S as SqlMigrationRunnerErrorCode, T as SqlMigrationRunnerFailure, _ as SqlMigrationPlanOperationStep, a as FieldEvent, b as SqlMigrationPlannerPlanOptions, c as MultiSpaceRunnerResult, d as SqlControlAdapterDescriptor, f as SqlControlExtensionDescriptor, g as SqlMigrationPlanOperation, h as SqlMigrationPlanContractInfo, i as ExpandNativeTypeInput, j as SqlPlannerConflictLocation, k as SqlPlannerConflict, l as MultiSpaceRunnerSuccessValue, m as SqlMigrationPlan, n as CodecControlHooks, o as FieldEventContext, p as SqlControlTargetDescriptor, r as CreateSqlMigrationPlanOptions, s as MultiSpaceRunnerFailure, t as AnyRecord, u as ResolveIdentityValueInput, v as SqlMigrationPlanOperationTarget, w as SqlMigrationRunnerExecuteOptions, x as SqlMigrationRunner, y as SqlMigrationPlanner } from "./types-hQoMXr54.mjs";
 import { ControlFamilyDescriptor, ControlStack, MigrationOperationClass, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan, MigrationPlanOperation, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, MutationDefaultGeneratorDescriptor, OpFactoryCall, TargetMigrationsCapability, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
 import { SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types";
 import { NotOk, Ok } from "@prisma-next/utils/result";

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-descriptor.ts","../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts","../src/core/migrations/field-event-planner.ts","../src/core/migrations/plan-helpers.ts","../src/core/migrations/policies.ts","../src/core/timestamp-now-generator.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;cAUa,mBAAA,YACA,uBAAA,QAA+B,wBAAA;EAAA,SAEjC,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,WAAA;EAAA,SACV,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKT,MAAA,0BAAA,CACE,KAAA,EAAO,YAAA,QAAoB,SAAA,IAC1B,wBAAA;AAAA;;;iBCHW,wBAAA,CACd,WAAA,EAAa,aAAA,CAAc,8BAAA,mBAC1B,GAAA,SAAY,iBAAA;;;;;;;;;ADdf;;;;KE2BY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;;;;;;;;KAYZ,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAA;;;;;;;;;;iBA+J3C,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UAiCK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;AAAA;;;;;;;;;;;;;;;iBAiBX,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;UCjPc,+BAAA;EHZI;;;;EAAA,SGiBV,aAAA,EAAe,QAAA,CAAS,UAAA;;;;WAIxB,WAAA,EAAa,QAAA,CAAS,UAAA;;;;;;;;;;WAUtB,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAAA,iBAY3B,wBAAA,CACd,OAAA,EAAS,+BAAA,YACC,aAAA;;;iBCiCI,mBAAA,gBAAA,CACd,OAAA,EAAS,6BAAA,CAA8B,cAAA,IACtC,gBAAA,CAAiB,cAAA;AAAA,iBAcJ,cAAA,gBAAA,CACd,IAAA,EAAM,gBAAA,CAAiB,cAAA,IACtB,uBAAA,CAAwB,cAAA;AAAA,iBAOX,cAAA,CAAe,SAAA,WAAoB,kBAAA,KAAuB,uBAAA;;;;iBAoB1D,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAA,CAAG,8BAAA;;;;iBAYS,aAAA,CACd,IAAA,EAAM,2BAAA,EACN,OAAA,UACA,OAAA;EAAY,GAAA;EAAc,IAAA,GAAO,SAAA;AAAA,IAChC,KAAA,CAAM,yBAAA;;;;;;cC1JI,oBAAA,EAAsB,0BAAA;;;;;;;;;;;;;;iBCsBnB,6BAAA,CAAA,GAAiC,kCAAA;;;;;;;;;;;iBAoBjC,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCyBlB,QAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-descriptor.ts","../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts","../src/core/migrations/field-event-planner.ts","../src/core/migrations/plan-helpers.ts","../src/core/migrations/policies.ts","../src/core/timestamp-now-generator.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;cAUa,mBAAA,YACA,uBAAA,QAA+B,wBAAA;EAAA,SAEjC,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,WAAA;EAAA,SACV,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKT,MAAA,0BAAA,CACE,KAAA,EAAO,YAAA,QAAoB,SAAA,IAC1B,wBAAA;AAAA;;;iBCHW,wBAAA,CACd,WAAA,EAAa,aAAA,CAAc,8BAAA,mBAC1B,GAAA,SAAY,iBAAA;;;;;;;;;ADdf;;;;KE2BY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;;;;;;;;KAYZ,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAA;;;;;;;;;;iBAgK3C,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UA8CK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;AAAA;;;;;;;;;;;;;;;iBAiBX,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;UC/Pc,+BAAA;EHZI;;;;EAAA,SGiBV,aAAA,EAAe,QAAA,CAAS,UAAA;;;;WAIxB,WAAA,EAAa,QAAA,CAAS,UAAA;;;;;;;;;;WAUtB,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAAA,iBAa3B,wBAAA,CACd,OAAA,EAAS,+BAAA,YACC,aAAA;;;iBCgCI,mBAAA,gBAAA,CACd,OAAA,EAAS,6BAAA,CAA8B,cAAA,IACtC,gBAAA,CAAiB,cAAA;AAAA,iBAcJ,cAAA,gBAAA,CACd,IAAA,EAAM,gBAAA,CAAiB,cAAA,IACtB,uBAAA,CAAwB,cAAA;AAAA,iBAOX,cAAA,CAAe,SAAA,WAAoB,kBAAA,KAAuB,uBAAA;;;;iBAoB1D,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAA,CAAG,8BAAA;;;;iBAYS,aAAA,CACd,IAAA,EAAM,2BAAA,EACN,OAAA,UACA,OAAA;EAAY,GAAA;EAAc,IAAA,GAAO,SAAA;AAAA,IAChC,KAAA,CAAM,yBAAA;;;;;;cC1JI,oBAAA,EAAsB,0BAAA;;;;;;;;;;;;;;iBCsBnB,6BAAA,CAAA,GAAiC,kCAAA;;;;;;;;;;;iBAoBjC,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCyBlB,QAAA"}

package/dist/control.mjs

@@ -1,6 +1,6 @@
 import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-F4JpCJl7.mjs";
-import { t as SqlContractSerializer } from "./sql-contract-serializer-qUQCnP-k.mjs";
-import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-BXw7yx6L.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-C6ypWJYR.mjs";
+import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-Bj4Wqe2c.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-Crewz6hG.mjs";
 import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-r7BP5n3l.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
@@ -9,7 +9,8 @@ import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/sp
 import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { StorageTable, isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma-next/framework-components/psl-ast";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -657,9 +658,14 @@ function buildPslDocumentAst(schemaIR, options) {
 	return {
 		kind: "document",
 		sourceId: "<sql-schema-ir>",
-		models: sortedModels,
-		enums,
-		compositeTypes: [],
+		namespaces: [{
+			kind: "namespace",
+			name: UNSPECIFIED_PSL_NAMESPACE_ID,
+			models: sortedModels,
+			enums,
+			compositeTypes: [],
+			span: SYNTHETIC_SPAN
+		}],
 		...types ? { types } : {},
 		span: SYNTHETIC_SPAN
 	};
@@ -1012,10 +1018,12 @@ function topologicalSort(models, tables, modelNameMap) {
 //#region src/core/control-instance.ts
 function extractCodecTypeIdsFromContract(contract) {
 	const typeIds = /* @__PURE__ */ new Set();
-	if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "tables" in contract.storage) {
-		const storage = contract.storage;
-		if (storage.tables && typeof storage.tables === "object") {
-			for (const table of Object.values(storage.tables)) if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
+	if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "namespaces" in contract.storage && typeof contract.storage.namespaces === "object" && contract.storage.namespaces !== null) {
+		const namespaces = contract.storage.namespaces;
+		for (const ns of Object.values(namespaces)) {
+			const tbls = ns.tables;
+			if (typeof tbls !== "object" || tbls === null) continue;
+			for (const table of Object.values(tbls)) if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
 				const columns = table.columns;
 				for (const column of Object.values(columns)) if (column && typeof column === "object" && "codecId" in column && typeof column.codecId === "string") typeIds.add(column.codecId);
 			}
@@ -1453,9 +1461,10 @@ function convertIndex(index) {
 }
 function convertForeignKey(fk) {
 	return {
-		columns: fk.columns,
-		referencedTable: fk.references.table,
-		referencedColumns: fk.references.columns,
+		columns: fk.source.columns,
+		referencedTable: fk.target.tableName,
+		referencedSchema: fk.target.namespaceId,
+		referencedColumns: fk.target.columns,
 		...ifDefined("name", fk.name)
 	};
 }
@@ -1470,12 +1479,12 @@ function convertTable(name, table, storageTypes, expandNativeType, renderDefault
 	const fkBackingIndexes = [];
 	for (const fk of table.foreignKeys) {
 		if (fk.index === false) continue;
-		const key = fk.columns.join(",");
+		const key = fk.source.columns.join(",");
 		if (satisfiedIndexColumns.has(key)) continue;
 		fkBackingIndexes.push({
-			columns: fk.columns,
+			columns: fk.source.columns,
 			unique: false,
-			name: defaultIndexName(name, fk.columns)
+			name: defaultIndexName(name, fk.source.columns)
 		});
 		satisfiedIndexColumns.add(key);
 	}
@@ -1501,21 +1510,30 @@ function detectDestructiveChanges(from, to) {
 	if (!from) return [];
 	const hasOwn = (value, key) => Object.hasOwn(value, key);
 	const conflicts = [];
-	for (const tableName of Object.keys(from.tables)) {
-		if (!hasOwn(to.tables, tableName)) {
-			conflicts.push({
-				kind: "tableRemoved",
-				summary: `Table "${tableName}" was removed`
+	const namespaceIds = [...new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	for (const namespaceId of namespaceIds) {
+		const fromNs = from.namespaces[namespaceId];
+		const toNs = to.namespaces[namespaceId];
+		const fromTables = fromNs?.tables;
+		if (!fromTables) continue;
+		for (const tableName of Object.keys(fromTables)) {
+			const toTableRaw = toNs?.tables[tableName];
+			if (!(toTableRaw instanceof StorageTable)) {
+				conflicts.push({
+					kind: "tableRemoved",
+					summary: `Table "${tableName}" was removed`
+				});
+				continue;
+			}
+			const toTable = toTableRaw;
+			const fromTableRaw = fromTables[tableName];
+			if (!(fromTableRaw instanceof StorageTable)) continue;
+			const fromTable = fromTableRaw;
+			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
+				kind: "columnRemoved",
+				summary: `Column "${tableName}"."${columnName}" was removed`
 			});
-			continue;
 		}
-		const toTable = to.tables[tableName];
-		const fromTable = from.tables[tableName];
-		if (!fromTable) continue;
-		for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
-			kind: "columnRemoved",
-			summary: `Column "${tableName}"."${columnName}" was removed`
-		});
 	}
 	return conflicts;
 }
@@ -1537,17 +1555,32 @@ function contractToSchemaIR(contract, options) {
 	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
 	if (!contract) return { tables: {} };
 	const storage = contract.storage;
-	const storageTypes = storage.types ?? {};
+	const allTypes = { ...storage.types ?? {} };
+	for (const ns of Object.values(storage.namespaces)) {
+		const nsTypes = ns.types;
+		if (nsTypes) for (const [k, v] of Object.entries(nsTypes)) allTypes[k] = v;
+	}
+	const storageTypes = allTypes;
 	const tables = {};
-	for (const [tableName, tableDef] of Object.entries(storage.tables)) tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault);
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.tables)) {
+		if (!(tableDefRaw instanceof StorageTable)) throw new Error(`contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.tables.${tableName}`);
+		const tableDef = tableDefRaw;
+		if (tables[tableName] !== void 0) throw new Error(`contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`);
+		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault);
+	}
 	return {
 		tables,
 		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace))
 	};
 }
 function deriveAnnotations(storage, annotationNamespace) {
-	const types = storage.types;
-	if (!types || Object.keys(types).length === 0) return void 0;
+	const allTypes = { ...storage.types ?? {} };
+	for (const ns of Object.values(storage.namespaces)) {
+		const nsTypes = ns.types;
+		if (nsTypes) for (const [k, v] of Object.entries(nsTypes)) allTypes[k] = v;
+	}
+	const types = allTypes;
+	if (Object.keys(types).length === 0) return void 0;
 	const byNativeType = {};
 	for (const typeInstance of Object.values(types)) {
 		if (isPostgresEnumStorageEntry(typeInstance)) {
@@ -1565,31 +1598,41 @@ function deriveAnnotations(storage, annotationNamespace) {
 //#endregion
 //#region src/core/migrations/field-event-planner.ts
 function planFieldEventOperations(options) {
-	const priorTables = options.priorContract?.storage.tables ?? {};
-	const newTables = options.newContract.storage.tables;
+	const priorContract = options.priorContract;
+	const newContract = options.newContract;
 	const added = [];
 	const dropped = [];
 	const altered = [];
-	const tableNames = unionSorted(Object.keys(priorTables), Object.keys(newTables));
-	for (const tableName of tableNames) {
-		const priorTable = priorTables[tableName];
-		const newTable = newTables[tableName];
-		const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
-		for (const fieldName of fieldNames) {
-			const priorField = priorTable?.columns[fieldName];
-			const newField = newTable?.columns[fieldName];
-			const entry = {
-				tableName,
-				fieldName,
-				priorTable,
-				newTable,
-				priorField,
-				newField
-			};
-			if (priorField === void 0 && newField !== void 0) added.push(entry);
-			else if (priorField !== void 0 && newField === void 0) dropped.push(entry);
-			else if (priorField !== void 0 && newField !== void 0) {
-				if (isAlteration(priorField, newField)) altered.push(entry);
+	const namespaceIds = unionSorted(priorContract ? Object.keys(priorContract.storage.namespaces) : [], Object.keys(newContract.storage.namespaces));
+	for (const namespaceId of namespaceIds) {
+		const priorNs = priorContract?.storage.namespaces[namespaceId];
+		const newNs = newContract.storage.namespaces[namespaceId];
+		const priorTables = priorNs?.tables;
+		const newTables = newNs?.tables;
+		const tableNames = unionSorted(priorTables ? Object.keys(priorTables) : [], newTables ? Object.keys(newTables) : []);
+		for (const tableName of tableNames) {
+			const priorTableRaw = priorTables?.[tableName];
+			const newTableRaw = newTables?.[tableName];
+			const priorTable = priorTableRaw instanceof StorageTable ? priorTableRaw : void 0;
+			const newTable = newTableRaw instanceof StorageTable ? newTableRaw : void 0;
+			const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
+			for (const fieldName of fieldNames) {
+				const priorField = priorTable?.columns[fieldName];
+				const newField = newTable?.columns[fieldName];
+				const entry = {
+					namespaceId,
+					tableName,
+					fieldName,
+					priorTable,
+					newTable,
+					priorField,
+					newField
+				};
+				if (priorField === void 0 && newField !== void 0) added.push(entry);
+				else if (priorField !== void 0 && newField === void 0) dropped.push(entry);
+				else if (priorField !== void 0 && newField !== void 0) {
+					if (isAlteration(priorField, newField)) altered.push(entry);
+				}
 			}
 		}
 	}
@@ -1619,6 +1662,7 @@ function appendCalls(event, entries, codecHooks, calls, pickCodecId) {
 */
 function buildContext(event, entry) {
 	const base = {
+		namespaceId: entry.namespaceId,
 		tableName: entry.tableName,
 		fieldName: entry.fieldName
 	};