@abapify/adt-plugin-gcts 0.4.34 → 0.4.37

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-CNh9ExCG.mjs";
 import { createPlugin, registerFormatPlugin } from "@abapify/adt-plugin";
-import { AdkClass, AdkDataElement, AdkDomain, AdkFunctionGroup, AdkInterface, AdkPackage, AdkProgram, AdkTable, AdkTableType, createAdk, getMainType, getTypeForKind } from "@abapify/adk";
+import { AdkClass, AdkDataElement, AdkDomain, AdkFunctionGroup, AdkFunctionModule, AdkInterface, AdkPackage, AdkProgram, AdkTable, AdkTableType, createAdk, getMainType, getTypeForKind } from "@abapify/adk";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -385,7 +385,7 @@ function affHeaderProps(ref) {
 		if (error instanceof Error && error.message.startsWith("No AFF schema")) return [];
 		throw error;
 	}
-	const header = (schema.properties ?? {}).header;
+	const header = schema.properties?.header;
 	return Object.keys(header && typeof header === "object" && header.properties ? header.properties : {});
 }
 const ajv = new Ajv2020({
@@ -744,6 +744,56 @@ function companionFiles(object, type, objectName, emitted, suffixToSourceKey) {
 		...propertyCompanionFiles(payload, objectName, typeLower)
 	].filter((f) => !emitted.has(f.path));
 }
+/**
+* Register a handler for an ADK class (preferred — `type` is derived from
+* the static `kind`) or an explicit type string (for types without an ADK
+* class, e.g. DOMA/DTEL).
+*/
+async function resolveSource(entry) {
+	return await (typeof entry.content === "function" ? entry.content() : entry.content);
+}
+/** Resolve the metadata file name for an object (custom hook or default). */
+function resolveMetadataFileName(definition, object, objectName, type) {
+	if (typeof definition.metadataFileName === "function") return definition.metadataFileName(object);
+	return definition.metadataFileName ?? gctsFilename(objectName, type, "metadata");
+}
+/**
+* Definition source entries → serialized files. Skips empty sources;
+* entries are resolved through the lazy `GctsSourceEntry` contract.
+*/
+async function serializeSourceFiles(object, definition, type, objectName) {
+	const files = [];
+	if (definition.getSources) for (const entry of definition.getSources(object)) {
+		const content = await resolveSource(entry);
+		if (!content) continue;
+		files.push({
+			path: gctsFilename(objectName, type, "source", entry.suffix, entry.ext),
+			content
+		});
+	}
+	else if (definition.getSource) {
+		const content = await definition.getSource(object);
+		if (content) files.push({
+			path: gctsFilename(objectName, type, "source"),
+			content
+		});
+	}
+	return files;
+}
+/** Extra files (e.g. FUGR per-function-module files) → serialized files. */
+async function serializeExtraFiles(object, definition) {
+	if (!definition.getExtraFiles) return [];
+	const files = [];
+	for (const extra of await definition.getExtraFiles(object)) {
+		const content = await resolveSource(extra);
+		if (!content) continue;
+		files.push({
+			path: extra.path,
+			content
+		});
+	}
+	return files;
+}
 function createHandler(adkClassOrType, definition) {
 	let type;
 	if (typeof adkClassOrType === "string") type = adkClassOrType;
@@ -754,9 +804,6 @@ function createHandler(adkClassOrType, definition) {
 		type = derived;
 	}
 	const fileExtension = getMainType(type).toLowerCase();
-	async function resolveSource(entry) {
-		return await (typeof entry.content === "function" ? entry.content() : entry.content);
-	}
 	const handler = {
 		type,
 		fileExtension,
@@ -766,41 +813,20 @@ function createHandler(adkClassOrType, definition) {
 		},
 		suffixToSourceKey: definition.suffixToSourceKey,
 		async serialize(object) {
-			const files = [];
 			const objectName = (object.name ?? "").toLowerCase();
-			if (definition.getSources) for (const entry of definition.getSources(object)) {
-				const content = await resolveSource(entry);
-				if (!content) continue;
-				files.push({
-					path: gctsFilename(objectName, type, "source", entry.suffix, entry.ext),
-					content
-				});
-			}
-			else if (definition.getSource) {
-				const content = await definition.getSource(object);
-				if (content) files.push({
-					path: gctsFilename(objectName, type, "source"),
-					content
-				});
-			}
+			const files = await serializeSourceFiles(object, definition, type, objectName);
 			const metadata = definition.toMetadata(object);
-			const metadataFile = typeof definition.metadataFileName === "function" ? definition.metadataFileName(object) : definition.metadataFileName ?? gctsFilename(objectName, type, "metadata");
-			files.push({
-				path: metadataFile,
+			const metadataFile = {
+				path: resolveMetadataFileName(definition, object, objectName, type),
 				content: buildMetadataFile(metadata)
-			});
-			if (definition.getExtraFiles) {
-				const extras = await definition.getExtraFiles(object);
-				for (const extra of extras) {
-					const content = await resolveSource(extra);
-					if (!content) continue;
-					files.push({
-						path: extra.path,
-						content
-					});
-				}
-			}
-			files.push(...companionFiles(object, type, objectName, new Set(files.map((f) => f.path)), definition.suffixToSourceKey));
+			};
+			const extraFiles = await serializeExtraFiles(object, definition);
+			const emitted = /* @__PURE__ */ new Set([
+				...files.map((f) => f.path),
+				metadataFile.path,
+				...extraFiles.map((f) => f.path)
+			]);
+			files.push(metadataFile, ...extraFiles, ...companionFiles(object, type, objectName, emitted, definition.suffixToSourceKey));
 			return files;
 		},
 		fromAbapGit: definition.fromMetadata ? (values) => definition.fromMetadata(values) : void 0,
@@ -950,7 +976,6 @@ const interfaceHandler = createHandler(AdkInterface, {
 *     generalInformation: { programType, programStatus, fixPointArithmetic?, ... }
 *   }
 */
-/** ADK sourceObjectStatus → AFF programStatus */
 const STATUS_TO_AFF = {
 	SAPStandardProduction: "sapProductionProgram",
 	customerProduction: "customerProductionProgram",
@@ -977,7 +1002,7 @@ const programHandler = createHandler(AdkProgram, {
 			generalInformation
 		};
 	},
-	getSource: (obj) => obj.getSource(),
+	getSource: (prog) => prog.getSource(),
 	fromMetadata: (meta) => ({
 		name: "",
 		type: "PROG/P",
@@ -1031,6 +1056,55 @@ const packageHandler = createHandler(AdkPackage, {
 	})
 });
 
+// src/lib/handlers/objects/ddic-data-type.ts
+const dataTypes = {
+	ACCP: true,
+	CHAR: true,
+	CLNT: true,
+	CUKY: true,
+	CURR: true,
+	DF16_DEC: true,
+	DF16_RAW: true,
+	DF16_SCL: true,
+	DECFLOAT16: true,
+	DF34_DEC: true,
+	DF34_RAW: true,
+	DF34_SCL: true,
+	DECFLOAT34: true,
+	DATS: true,
+	DATN: true,
+	DEC: true,
+	FLTP: true,
+	GEOM_EWKB: true,
+	INT1: true,
+	INT2: true,
+	INT4: true,
+	INT8: true,
+	LANG: true,
+	LCHR: true,
+	LRAW: true,
+	NUMC: true,
+	PREC: true,
+	QUAN: true,
+	RAW: true,
+	RAWSTRING: true,
+	SSTRING: true,
+	STRING: true,
+	TIMS: true,
+	TIMN: true,
+	UNIT: true,
+	UTCLONG: true,
+	VARC: true
+};
+/** Validate the open ADT type code before writing the narrower AFF enum. */
+function affDataType(value) {
+	if (isAffDataType(value)) return value;
+	throw new Error(`Unsupported AFF DDIC data type: ${String(value)}`);
+}
+function isAffDataType(value) {
+	return typeof value === "string" && Object.hasOwn(dataTypes, value);
+}
+
 // src/lib/handlers/objects/doma.ts
 /**
 * DOMA (domain) handler for gCTS / AFF format.
@@ -1048,16 +1122,16 @@ const packageHandler = createHandler(AdkPackage, {
 const domainHandler = createHandler(AdkDomain, {
 	toMetadata(doma) {
 		const data = doma.dataSync;
-		const content = data.content ?? {};
+		const content = data.content;
 		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
-		const ti = content.typeInformation ?? {};
-		const oi = content.outputInformation ?? {};
-		const vi = content.valueInformation ?? {};
+		const ti = content?.typeInformation;
+		const oi = content?.outputInformation;
+		const vi = content?.valueInformation;
 		const format = {
-			dataType: ti.datatype ?? "CHAR",
-			length: ti.length ?? 1
+			dataType: affDataType(ti?.datatype ?? "CHAR"),
+			length: ti?.length ?? 1
 		};
-		if (typeof ti.decimals === "number") format.decimals = ti.decimals;
+		if (typeof ti?.decimals === "number") format.decimals = ti.decimals;
 		const result = {
 			formatVersion: "1",
 			header: {
@@ -1067,12 +1141,12 @@ const domainHandler = createHandler(AdkDomain, {
 			format
 		};
 		const outChars = {};
-		if (typeof oi.length === "number") outChars.length = oi.length;
-		if (typeof oi.lowercase === "boolean") outChars.caseSensitive = !oi.lowercase;
-		if (oi.conversionExit) outChars.conversionRoutine = oi.conversionExit;
+		if (typeof oi?.length === "number") outChars.length = oi.length;
+		if (typeof oi?.lowercase === "boolean") outChars.caseSensitive = !oi.lowercase;
+		if (oi?.conversionExit) outChars.conversionRoutine = oi.conversionExit;
 		if (Object.keys(outChars).length > 0) result.outputCharacteristics = outChars;
-		const vtRef = vi.valueTableRef ?? {};
-		if (vtRef.name) result.valueTable = { name: vtRef.name };
+		const vtRef = vi?.valueTableRef;
+		if (vtRef?.name) result.valueTable = { name: vtRef.name };
 		return result;
 	},
 	fromMetadata: (meta) => {
@@ -1112,10 +1186,13 @@ const domainHandler = createHandler(AdkDomain, {
 *   }
 */
 function buildDataTypeInformation(data) {
-	if (data.typeKind === "domain" && data.typeName) return { domainName: data.typeName };
+	if (data.typeKind === "domain" && typeof data.typeName === "string" && data.typeName) return { domainName: data.typeName };
 	if (data.dataType) {
-		const predefinedType = { dataType: data.dataType };
-		if (typeof data.dataTypeLength === "number") predefinedType.length = data.dataTypeLength;
+		if (typeof data.dataTypeLength !== "number") throw new TypeError("AFF predefined DDIC type requires a length");
+		const predefinedType = {
+			dataType: affDataType(data.dataType),
+			length: data.dataTypeLength
+		};
 		if (typeof data.dataTypeDecimals === "number") predefinedType.decimals = data.dataTypeDecimals;
 		return { predefinedType };
 	}
@@ -1144,9 +1221,13 @@ function buildFieldLabels(data) {
 			"heading",
 			"headingFieldLength"
 		]
-	]) if (data[src]) {
-		labels[dst] = data[src];
-		if (typeof data[lenKey] === "number") labels[`${dst}Length`] = data[lenKey];
+	]) {
+		const label = data[src];
+		const length = data[lenKey];
+		if (typeof label === "string" && label) {
+			labels[dst] = label;
+			if (typeof length === "number") labels[`${dst}Length`] = length;
+		}
 	}
 	return labels;
 }
@@ -1336,6 +1417,41 @@ const functionGroupHandler = createHandler(AdkFunctionGroup, {
 	})
 });
 
+// src/lib/handlers/objects/func.ts
+/**
+* FUNC (function module) handler for gCTS / AFF format.
+*
+* Projects ADK function module data to the AFF func-v1.json schema shape.
+* A function module is a child of a function group, but it can also be
+* serialized as its own ADK object (FUNC) for the gCTS file format.
+*/
+const functionModuleHandler = createHandler(AdkFunctionModule, {
+	toMetadata(func) {
+		const data = func.dataSync ?? {};
+		const meta = {
+			formatVersion: "1",
+			header: { description: func.description ?? data.description ?? "" },
+			processingType: data.processingType ?? "normal",
+			includeNumber: data.includeNumber ?? "0000"
+		};
+		if (data.rfcProperties && typeof data.rfcProperties === "object") meta.rfcProperties = data.rfcProperties;
+		if (data.updateProperties && typeof data.updateProperties === "object") meta.updateProperties = data.updateProperties;
+		if (typeof data.releaseState === "string") meta.releaseState = data.releaseState;
+		if (typeof data.global === "boolean") meta.global = data.global;
+		if (typeof data.exceptionClasses === "boolean") meta.exceptionClasses = data.exceptionClasses;
+		return meta;
+	},
+	getSource: (func) => typeof func.getSource === "function" ? func.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		processingType: meta.processingType,
+		includeNumber: meta.includeNumber
+	})
+});
+
 // src/lib/handlers/objects/ddls.ts
 /**
 * DDLS (CDS view) handler for gCTS / AFF format.
@@ -1351,6 +1467,56 @@ const functionGroupHandler = createHandler(AdkFunctionGroup, {
 *     parentName?: string
 *   }
 */
+const languageVersions = {
+	standard: true,
+	keyUser: true,
+	cloudDevelopment: true
+};
+const sourceOrigins = {
+	abapDevelopmentTools: true,
+	customCdsViews: true,
+	customAnalyticalQueries: true,
+	customBusinessObject: true,
+	customCodeList: true,
+	customCdsViewsVariantConfg: true,
+	customFields: true,
+	extensionsForDataSources: true,
+	customSearchModeler: true,
+	serviceConsumptionModel: true
+};
+const sourceTypes = {
+	ddicBasedView: true,
+	viewEntity: true,
+	viewExtend: true,
+	viewEntityExtend: true,
+	tableFunction: true,
+	tableEntity: true,
+	abstractEntity: true,
+	customEntity: true,
+	hierarchy: true,
+	projectionView: true,
+	externalEntity: true,
+	unknown: true
+};
+/**
+* ADK exposes these fields as open strings, so the compile-time enum types do
+* not protect the serialized output. Reject values outside the AFF enum.
+* Non-strings are rejected before property lookup: an array such as
+* `['viewEntity']` would otherwise coerce to a valid key and be emitted.
+*/
+function isAffEnumValue(allowed, value) {
+	return typeof value === "string" && Object.hasOwn(allowed, value);
+}
+function mismatchDetail(value) {
+	if (typeof value === "string") return value;
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function affEnum(allowed, field, value) {
+	if (isAffEnumValue(allowed, value)) return value;
+	throw new Error(`Unsupported AFF DDLS ${field}: ${mismatchDetail(value)}`);
+}
 const ddlSourceHandler = createHandler("DDLS", {
 	toMetadata(obj) {
 		const lang = (obj.originalLanguage ?? "").toLowerCase();
@@ -1359,10 +1525,10 @@ const ddlSourceHandler = createHandler("DDLS", {
 			header: {
 				description: obj.description ?? obj.name ?? "",
 				originalLanguage: lang,
-				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+				...obj.abapLanguageVersion ? { abapLanguageVersion: affEnum(languageVersions, "abapLanguageVersion", obj.abapLanguageVersion) } : {}
 			},
-			sourceOrigin: obj.sourceOrigin ?? "abapDevelopmentTools",
-			sourceType: obj.sourceType ?? "unknown"
+			sourceOrigin: affEnum(sourceOrigins, "sourceOrigin", obj.sourceOrigin ?? "abapDevelopmentTools"),
+			sourceType: affEnum(sourceTypes, "sourceType", obj.sourceType ?? "unknown")
 		};
 	},
 	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
@@ -1703,6 +1869,67 @@ function abapLangVerToAdt(code) {
 	return ABAP_LANG_VER_TO_ADT[code] ?? code;
 }
 /**
+* Register one `.json` file in the object index.
+*
+* Packages are NOT deployed (same convention as abapGit's `package.devc.xml`)
+* — they must exist on target. `{name}.{type}.docu.json` is a DOCU
+* companion, not a second metadata anchor — without this it can overwrite
+* metadataFile depending on glob order. Other suffixed `.json` companions
+* (LIMU sub-object metadata, `{sub}.{stype}`) flow through the source
+* pipeline with an explicit `json` ext marker.
+*/
+function registerJsonAnchor(jsonPath, objectMap, supportedTypes) {
+	const filename = jsonPath.split("/").pop();
+	if (filename === "package.devc.json") return;
+	const parsed = parseGctsFilename(filename);
+	if (!parsed) return;
+	if (parsed.extension !== "json") return;
+	if (!supportedTypes.has(parsed.type.toLowerCase())) return;
+	const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
+	if (!objectMap.has(key)) objectMap.set(key, {
+		name: parsed.name.toUpperCase(),
+		type: parsed.type.toUpperCase(),
+		sourceFiles: [],
+		propertyFiles: []
+	});
+	const entry = objectMap.get(key);
+	if (parsed.suffix === "docu") entry.docuFile = jsonPath;
+	else if (parsed.suffix) entry.sourceFiles.push({
+		path: jsonPath,
+		suffix: parsed.suffix,
+		ext: "json"
+	});
+	else entry.metadataFile = jsonPath;
+}
+/**
+* Register a `.properties` translation companion — routed into
+* `data.properties` so it round-trips through metadata, not source staging.
+*/
+function registerPropertyFile(path, objectMap) {
+	const filename = path.split("/").pop();
+	const parsed = parseGctsFilename(filename);
+	if (!parsed) return;
+	const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
+	objectMap.get(key)?.propertyFiles.push({
+		path,
+		suffix: parsed.suffix
+	});
+}
+/** Register a source file (.abap/.asddls/.asdcls) with its object group. */
+function registerSourceFile(path, objectMap) {
+	const filename = path.split("/").pop();
+	const parsed = parseGctsFilename(filename);
+	if (!parsed) return;
+	const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
+	const obj = objectMap.get(key);
+	if (!obj) return;
+	obj.sourceFiles.push({
+		path,
+		suffix: parsed.suffix,
+		ext: parsed.extension
+	});
+}
+/**
 * Deserialise a gCTS/AFF file tree into `AdkObject` instances.
 *
 * @param fileTree  Virtual FS abstraction (checkin supplies a real-fs impl).
@@ -1716,56 +1943,10 @@ async function* deserialize(fileTree, client, options) {
 	const jsonFiles = await fileTree.glob("**/*.json");
 	const supportedTypes = new Set(getSupportedTypes().map((t) => t.toLowerCase()));
 	const objectMap = /* @__PURE__ */ new Map();
-	for (const jsonPath of jsonFiles) {
-		const filename = jsonPath.split("/").pop();
-		if (filename === "package.devc.json") continue;
-		const parsed = parseGctsFilename(filename);
-		if (!parsed) continue;
-		if (parsed.extension !== "json") continue;
-		if (!supportedTypes.has(parsed.type.toLowerCase())) continue;
-		const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
-		if (!objectMap.has(key)) objectMap.set(key, {
-			name: parsed.name.toUpperCase(),
-			type: parsed.type.toUpperCase(),
-			sourceFiles: [],
-			propertyFiles: []
-		});
-		if (parsed.suffix === "docu") objectMap.get(key).docuFile = jsonPath;
-		else if (parsed.suffix) {
-			objectMap.get(key).sourceFiles.push({
-				path: jsonPath,
-				suffix: parsed.suffix,
-				ext: "json"
-			});
-			continue;
-		} else objectMap.get(key).metadataFile = jsonPath;
-	}
-	for (const path of await fileTree.glob("**/*.properties")) {
-		const filename = path.split("/").pop();
-		const parsed = parseGctsFilename(filename);
-		if (!parsed) continue;
-		const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
-		objectMap.get(key)?.propertyFiles.push({
-			path,
-			suffix: parsed.suffix
-		});
-	}
-	for (const ext of SOURCE_EXTENSIONS) {
-		const paths = await fileTree.glob(`**/*.${ext}`);
-		for (const path of paths) {
-			const filename = path.split("/").pop();
-			const parsed = parseGctsFilename(filename);
-			if (!parsed) continue;
-			const key = `${parsed.name.toUpperCase()}:${parsed.type.toUpperCase()}`;
-			const obj = objectMap.get(key);
-			if (!obj) continue;
-			obj.sourceFiles.push({
-				path,
-				suffix: parsed.suffix,
-				ext: parsed.extension
-			});
-		}
-	}
+	for (const jsonPath of jsonFiles) registerJsonAnchor(jsonPath, objectMap, supportedTypes);
+	for (const path of await fileTree.glob("**/*.properties")) registerPropertyFile(path, objectMap);
+	const pathsByExtension = await Promise.all(Array.from(SOURCE_EXTENSIONS).map((ext) => fileTree.glob(`**/*.${ext}`)));
+	for (const paths of pathsByExtension) for (const path of paths) registerSourceFile(path, objectMap);
 	const readThrottled = throttledReader(fileTree);
 	const entries = [...objectMap.values()];
 	const pending = /* @__PURE__ */ new Map();