@abapify/adt-plugin-gcts 0.4.0 → 0.4.3

package/dist/index.mjs

@@ -0,0 +1,1291 @@
+import { createPlugin, registerFormatPlugin } from "@abapify/adt-plugin";
+import { AdkClass, AdkDataElement, AdkDomain, AdkFunctionGroup, AdkInterface, AdkPackage, AdkProgram, AdkTable, AdkTableType, createAdk, getMainType, getTypeForKind } from "@abapify/adk";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+//#region src/lib/format/filename.ts
+/**
+* Extension used for the source-file part of each object type.
+*
+* Order of precedence: CDS types use AFF's `.asddls` / `.asdcls`; everything
+* else uses `.abap`. Metadata is always `.json`.
+*/
+const TYPE_TO_SOURCE_EXT = {
+	CLAS: "abap",
+	INTF: "abap",
+	PROG: "abap",
+	FUGR: "abap",
+	FUNC: "abap",
+	DDLS: "asddls",
+	DCLS: "asdcls",
+	BDEF: "abdl",
+	SRVD: "acds"
+};
+/** Metadata extension for all AFF/gCTS objects. */
+const METADATA_EXTENSION = "json";
+/** Fixed filename for package metadata (AFF / gCTS convention). */
+const PACKAGE_FILENAME = "package.devc.json";
+/**
+* Build the AFF/gCTS on-disk filename for an object.
+*
+* @param name     Object name (case preserved — AFF normalises to lowercase)
+* @param type     ABAP object type code (CLAS, INTF, ...)
+* @param kind     `"metadata"` (default) or `"source"`.
+* @param suffix   Optional sub-include suffix (e.g. `locals_def` for CLAS).
+*/
+function gctsFilename(name, type, kind = "metadata", suffix) {
+	const base = name.toLowerCase();
+	const typeLower = mainType(type).toLowerCase();
+	if (kind === "metadata") return `${base}.${typeLower}.${METADATA_EXTENSION}`;
+	const ext = TYPE_TO_SOURCE_EXT[mainType(type).toUpperCase()] ?? "abap";
+	return suffix ? `${base}.${typeLower}.${suffix}.${ext}` : `${base}.${typeLower}.${ext}`;
+}
+/**
+* Parse an AFF/gCTS filename back into its components.
+*
+* Returns `undefined` if the filename does not look like a known AFF/gCTS
+* artefact — callers should skip unknown files (e.g. `README.md`).
+*/
+function parseGctsFilename(filename) {
+	if (filename === "package.devc.json") return {
+		name: "",
+		type: "DEVC",
+		extension: METADATA_EXTENSION
+	};
+	const parts = filename.split(".");
+	if (parts.length < 3) return;
+	const extension = parts.at(-1);
+	const nameParts = (parts.length >= 4 ? parts.at(-2) : void 0) ? parts.slice(0, -3) : parts.slice(0, -2);
+	if (nameParts.length === 0) return;
+	if (extension === "json") return {
+		name: nameParts.length === 0 ? "" : parts.slice(0, -2).join("."),
+		type: parts.at(-2).toUpperCase(),
+		extension
+	};
+	if (!(/* @__PURE__ */ new Set([
+		"abap",
+		"asddls",
+		"asdcls",
+		"abdl",
+		"acds",
+		"properties"
+	])).has(extension)) return;
+	if (parts.length >= 4) return {
+		name: parts.slice(0, -3).join("."),
+		type: parts.at(-3).toUpperCase(),
+		suffix: parts.at(-2),
+		extension
+	};
+	return {
+		name: parts.slice(0, -2).join("."),
+		type: parts.at(-2).toUpperCase(),
+		extension
+	};
+}
+/**
+* Translate an ADT object URI (e.g. `/sap/bc/adt/oo/classes/zcl_foo`) to
+* the AFF/gCTS on-disk path (e.g. `zcl_foo/zcl_foo.clas.json`).
+*
+* Matches the `adtUriToAbapGitPath` helper in the abapGit plugin.
+*/
+function adtUriToGctsPath(uri) {
+	if (!uri.startsWith("/sap/bc/adt/")) return void 0;
+	const tail = uri.slice(12);
+	if (tail.length === 0) return void 0;
+	for (const [pattern, type] of [
+		[/^oo\/classes\/([^/]+)$/, "CLAS"],
+		[/^oo\/interfaces\/([^/]+)$/, "INTF"],
+		[/^programs\/programs\/([^/]+)$/, "PROG"],
+		[/^functions\/groups\/([^/]+)$/, "FUGR"],
+		[/^packages\/([^/]+)$/, "DEVC"],
+		[/^ddic\/domains\/([^/]+)$/, "DOMA"],
+		[/^ddic\/dataelements\/([^/]+)$/, "DTEL"],
+		[/^ddic\/structures\/([^/]+)$/, "TABL"],
+		[/^ddic\/tables\/([^/]+)$/, "TABL"],
+		[/^ddic\/tabletypes\/([^/]+)$/, "TTYP"],
+		[/^ddic\/ddl\/sources\/([^/]+)$/, "DDLS"],
+		[/^acm\/dcls\/sources\/([^/]+)$/, "DCLS"]
+	]) {
+		const m = pattern.exec(tail);
+		if (m) {
+			const name = m[1];
+			if (type === "DEVC") return `${name.toLowerCase()}/${PACKAGE_FILENAME}`;
+			return `${name.toLowerCase()}/${gctsFilename(name, type)}`;
+		}
+	}
+}
+function mainType(type) {
+	return type.split("/")[0];
+}
+
+//#endregion
+//#region src/lib/handlers/base.ts
+const handlerRegistry = /* @__PURE__ */ new Map();
+/** Look up a handler (full-type first, then main-type fallback). */
+function getHandler(type) {
+	return handlerRegistry.get(type) ?? handlerRegistry.get(getMainType(type));
+}
+/** `true` iff the given object type has a registered handler. */
+function isSupported(type) {
+	return handlerRegistry.has(type) || handlerRegistry.has(getMainType(type));
+}
+/** Snapshot of all registered object types. */
+function getSupportedTypes() {
+	return [...handlerRegistry.keys()];
+}
+/**
+* Build a JSON metadata file for the object. JSON is pretty-printed (2-space
+* indent) so the output is diff-friendly and matches AFF's own tooling.
+*/
+function buildMetadataFile(meta) {
+	return JSON.stringify(meta, null, 2) + "\n";
+}
+function createHandler(adkClassOrType, definition) {
+	let type;
+	if (typeof adkClassOrType === "string") type = adkClassOrType;
+	else {
+		const kind = adkClassOrType.kind;
+		const derived = getTypeForKind(kind);
+		if (!derived) throw new Error(`Unknown ADK kind: ${kind}. Ensure the ADK class has a static 'kind' property.`);
+		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,
+		schema: {
+			parse: (raw) => JSON.parse(raw),
+			build: (data) => JSON.stringify(data, null, 2) + "\n"
+		},
+		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),
+					content
+				});
+			}
+			else if (definition.getSource) {
+				const content = await definition.getSource(object);
+				if (content) files.push({
+					path: gctsFilename(objectName, type, "source"),
+					content
+				});
+			}
+			const metadata = definition.toMetadata(object);
+			const metadataFile = typeof definition.metadataFileName === "function" ? definition.metadataFileName(object) : definition.metadataFileName ?? gctsFilename(objectName, type, "metadata");
+			files.push({
+				path: metadataFile,
+				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
+					});
+				}
+			}
+			return files;
+		},
+		fromAbapGit: definition.fromMetadata ? (values) => definition.fromMetadata(values) : void 0,
+		setSources: definition.setSources
+	};
+	handlerRegistry.set(type, handler);
+	return handler;
+}
+
+//#endregion
+//#region src/lib/handlers/objects/clas.ts
+/**
+* CLAS handler for gCTS / AFF format.
+*
+* Projects ADK class data to the AFF clas-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     category?,
+*     fixPointArithmetic?,
+*     messageClass?,
+*     descriptions?: { types?, attributes?, events?, methods? }
+*   }
+*
+* Sources are emitted per include (main, definitions, implementations, ...).
+* Abapgit suffix convention is reused for consistency — AFF does not
+* standardise include filenames, but using the same suffixes as abapGit
+* means downstream tooling (diff, round-trip) can treat both formats with
+* the same suffix map.
+*/
+const SUFFIX = {
+	main: void 0,
+	definitions: "locals_def",
+	implementations: "locals_imp",
+	localtypes: "locals_types",
+	macros: "macros",
+	testclasses: "testclasses"
+};
+const SUFFIX_TO_SOURCE_KEY = Object.fromEntries(Object.entries(SUFFIX).filter(([, v]) => v !== void 0).map(([k, v]) => [v, k]));
+/**
+* ADK category enum → AFF category enum.
+* AFF uses a different, finer-grained set of category names.
+*/
+const CATEGORY_TO_AFF = {
+	generalObjectType: "generalObjectType",
+	exitClass: "exitClass",
+	testClass: "testclassAbapUnit",
+	behaviorPool: "behaviorClass",
+	entityEventHandler: "entityEventHandler",
+	persistentClass: "persistentClass",
+	factoryClass: "factoryForPersistentClass",
+	rfcProxyClass: "rfcProxyClass",
+	communicationConnectionClass: "communicationConnectionClass",
+	exceptionClass: "exceptionClass",
+	areaClass: "areaClassSharedObjects",
+	bspClass: "bspApplicationClass"
+};
+const CATEGORY_FROM_AFF = Object.fromEntries(Object.entries(CATEGORY_TO_AFF).map(([k, v]) => [v, k]));
+const classHandler = createHandler(AdkClass, {
+	suffixToSourceKey: SUFFIX_TO_SOURCE_KEY,
+	toMetadata(cls) {
+		const data = cls.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: cls.description ?? data.description ?? "",
+				originalLanguage: lang,
+				...data.abapLanguageVersion && data.abapLanguageVersion !== "standard" ? { abapLanguageVersion: data.abapLanguageVersion } : {}
+			},
+			...data.category ? { category: CATEGORY_TO_AFF[data.category] ?? "generalObjectType" } : {},
+			...typeof data.fixPointArithmetic === "boolean" ? { fixPointArithmetic: data.fixPointArithmetic } : {}
+		};
+	},
+	getSources: (cls) => {
+		return (cls.dataSync.include ?? []).map((inc) => ({
+			suffix: SUFFIX[String(inc.includeType ?? "main")],
+			content: () => cls.getIncludeSource(String(inc.includeType ?? "main"))
+		}));
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		type: "CLAS/OC",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		category: meta.category ? CATEGORY_FROM_AFF[meta.category] ?? meta.category : void 0,
+		abapLanguageVersion: meta.header.abapLanguageVersion,
+		fixPointArithmetic: meta.fixPointArithmetic
+	}),
+	setSources: (cls, sources) => {
+		cls._pendingSources = sources;
+		if (sources.main) cls._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/intf.ts
+/**
+* INTF handler for gCTS / AFF format.
+*
+* Projects ADK interface data to the AFF intf-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     category?,
+*     proxy?,
+*     descriptions?
+*   }
+*/
+const interfaceHandler = createHandler(AdkInterface, {
+	toMetadata(intf) {
+		const data = intf.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: intf.description ?? data.description ?? "",
+				originalLanguage: lang,
+				...data.abapLanguageVersion && data.abapLanguageVersion !== "standard" ? { abapLanguageVersion: data.abapLanguageVersion } : {}
+			}
+		};
+	},
+	getSource: (obj) => obj.getSource(),
+	fromMetadata: (meta) => ({
+		name: "",
+		type: "INTF/OI",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		abapLanguageVersion: meta.header.abapLanguageVersion
+	}),
+	setSources: (intf, sources) => {
+		if (sources.main) intf._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/prog.ts
+/**
+* PROG handler for gCTS / AFF format.
+*
+* Projects ADK program data to the AFF prog-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     generalInformation: { programType, programStatus, fixPointArithmetic?, ... }
+*   }
+*/
+/** ADK sourceObjectStatus → AFF programStatus */
+const STATUS_TO_AFF = {
+	SAPStandardProduction: "sapProductionProgram",
+	customerProduction: "customerProductionProgram",
+	system: "systemProgram",
+	test: "testProgram"
+};
+const STATUS_FROM_AFF = Object.fromEntries(Object.entries(STATUS_TO_AFF).map(([k, v]) => [v, k]));
+const programHandler = createHandler(AdkProgram, {
+	toMetadata(prog) {
+		const data = prog.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		const generalInformation = {
+			programType: data.programType ?? "executableProgram",
+			programStatus: STATUS_TO_AFF[data.sourceObjectStatus ?? ""] ?? "systemProgram"
+		};
+		if (typeof data.fixPointArithmetic === "boolean") generalInformation.fixPointArithmetic = data.fixPointArithmetic;
+		return {
+			formatVersion: "1",
+			header: {
+				description: prog.description ?? data.description ?? "",
+				originalLanguage: lang,
+				...data.abapLanguageVersion && data.abapLanguageVersion !== "standard" ? { abapLanguageVersion: data.abapLanguageVersion } : {}
+			},
+			generalInformation
+		};
+	},
+	getSource: (obj) => obj.getSource(),
+	fromMetadata: (meta) => ({
+		name: "",
+		type: "PROG/P",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		programType: meta.generalInformation?.programType,
+		sourceObjectStatus: meta.generalInformation?.programStatus ? STATUS_FROM_AFF[meta.generalInformation.programStatus] : void 0,
+		fixPointArithmetic: meta.generalInformation?.fixPointArithmetic,
+		abapLanguageVersion: meta.header.abapLanguageVersion
+	}),
+	setSources: (prog, sources) => {
+		if (sources.main) prog._pendingSource = sources.main;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/devc.ts
+/**
+* DEVC (package) handler for gCTS / AFF format.
+*
+* Packages use a fixed filename (`package.devc.json`) — same convention as
+* abapGit's `package.devc.xml`.
+*
+* Note: DEVC has no AFF schema in SAP/abap-file-formats — this handler
+* uses a gCTS-compatible shape with formatVersion "1". If AFF adds a DEVC
+* schema later, align here.
+*/
+const packageHandler = createHandler(AdkPackage, {
+	metadataFileName: PACKAGE_FILENAME,
+	toMetadata(pkg) {
+		return {
+			formatVersion: "1",
+			header: {
+				description: pkg.description ?? "",
+				originalLanguage: (pkg.dataSync?.language ?? pkg.dataSync?.masterLanguage ?? "").toLowerCase(),
+				...pkg.dataSync?.abapLanguageVersion && pkg.dataSync.abapLanguageVersion !== "standard" ? { abapLanguageVersion: pkg.dataSync.abapLanguageVersion } : {}
+			},
+			package: {
+				softwareComponent: pkg.dataSync?.transport?.softwareComponent?.name,
+				applicationComponent: pkg.dataSync?.applicationComponent?.name,
+				packageType: pkg.dataSync?.attributes?.packageType
+			}
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta?.header?.description,
+		language: meta?.header?.originalLanguage?.toUpperCase(),
+		masterLanguage: meta?.header?.originalLanguage?.toUpperCase(),
+		abapLanguageVersion: meta?.header?.abapLanguageVersion
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/doma.ts
+/**
+* DOMA (domain) handler for gCTS / AFF format.
+*
+* Projects ADK domain data to the AFF doma-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     format: { dataType, length, decimals? } (required),
+*     outputCharacteristics?: { length?, caseSensitive?, conversionRoutine?, ... },
+*     valueTable?: { name }
+*   }
+*/
+const domainHandler = createHandler(AdkDomain, {
+	toMetadata(doma) {
+		const data = doma.dataSync;
+		const content = data.content ?? {};
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		const ti = content.typeInformation ?? {};
+		const oi = content.outputInformation ?? {};
+		const vi = content.valueInformation ?? {};
+		const format = {
+			dataType: ti.datatype ?? "CHAR",
+			length: ti.length ?? 1
+		};
+		if (typeof ti.decimals === "number") format.decimals = ti.decimals;
+		const result = {
+			formatVersion: "1",
+			header: {
+				description: doma.description ?? "",
+				originalLanguage: lang
+			},
+			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 (Object.keys(outChars).length > 0) result.outputCharacteristics = outChars;
+		const vtRef = vi.valueTableRef ?? {};
+		if (vtRef.name) result.valueTable = { name: vtRef.name };
+		return result;
+	},
+	fromMetadata: (meta) => {
+		const result = {
+			name: "",
+			description: meta.header.description,
+			language: meta.header.originalLanguage?.toUpperCase(),
+			masterLanguage: meta.header.originalLanguage?.toUpperCase()
+		};
+		const content = { typeInformation: {
+			datatype: meta.format.dataType,
+			length: meta.format.length,
+			decimals: meta.format.decimals ?? 0
+		} };
+		if (meta.outputCharacteristics) content.outputInformation = {
+			length: meta.outputCharacteristics.length,
+			lowercase: meta.outputCharacteristics.caseSensitive ? false : void 0,
+			conversionExit: meta.outputCharacteristics.conversionRoutine
+		};
+		if (meta.valueTable?.name) content.valueInformation = { valueTableRef: { name: meta.valueTable.name } };
+		result.content = content;
+		return result;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/dtel.ts
+/**
+* DTEL (data element) handler for gCTS / AFF format.
+*
+* Projects ADK data element data to the AFF dtel-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     dataTypeInformation: { domainName? } | { predefinedType: { dataType, length?, decimals? } },
+*     fieldLabels?: { short, shortLength, medium, mediumLength, long, longLength, heading, headingLength }
+*   }
+*/
+function buildDataTypeInformation(data) {
+	if (data.typeKind === "domain" && 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.dataTypeDecimals === "number") predefinedType.decimals = data.dataTypeDecimals;
+		return { predefinedType };
+	}
+	return {};
+}
+function buildFieldLabels(data) {
+	const labels = {};
+	for (const [src, dst, lenKey] of [
+		[
+			"shortFieldLabel",
+			"short",
+			"shortFieldLength"
+		],
+		[
+			"mediumFieldLabel",
+			"medium",
+			"mediumFieldLength"
+		],
+		[
+			"longFieldLabel",
+			"long",
+			"longFieldLength"
+		],
+		[
+			"headingFieldLabel",
+			"heading",
+			"headingFieldLength"
+		]
+	]) if (data[src]) {
+		labels[dst] = data[src];
+		if (typeof data[lenKey] === "number") labels[`${dst}Length`] = data[lenKey];
+	}
+	return labels;
+}
+const dataElementHandler = createHandler(AdkDataElement, {
+	toMetadata(dtel) {
+		const data = dtel.dataSync;
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		const result = {
+			formatVersion: "1",
+			header: {
+				description: dtel.description ?? "",
+				originalLanguage: lang
+			},
+			dataTypeInformation: buildDataTypeInformation(data)
+		};
+		const fieldLabels = buildFieldLabels(data);
+		if (Object.keys(fieldLabels).length > 0) result.fieldLabels = fieldLabels;
+		return result;
+	},
+	fromMetadata: (meta) => {
+		const dti = meta.dataTypeInformation ?? {};
+		const result = {
+			name: "",
+			description: meta.header.description,
+			language: meta.header.originalLanguage?.toUpperCase(),
+			masterLanguage: meta.header.originalLanguage?.toUpperCase()
+		};
+		if (dti.domainName) {
+			result.typeKind = "domain";
+			result.typeName = dti.domainName;
+		} else if (dti.predefinedType) {
+			result.typeKind = "predefinedAbapType";
+			result.dataType = dti.predefinedType.dataType;
+			result.dataTypeLength = dti.predefinedType.length;
+			result.dataTypeDecimals = dti.predefinedType.decimals;
+		}
+		const fl = meta.fieldLabels;
+		if (fl) {
+			result.shortFieldLabel = fl.short;
+			result.shortFieldLength = fl.shortLength;
+			result.mediumFieldLabel = fl.medium;
+			result.mediumFieldLength = fl.mediumLength;
+			result.longFieldLabel = fl.long;
+			result.longFieldLength = fl.longLength;
+			result.headingFieldLabel = fl.heading;
+			result.headingFieldLength = fl.headingLength;
+		}
+		return result;
+	}
+});
+
+//#endregion
+//#region src/lib/handlers/objects/tabl.ts
+/**
+* TABL (table / structure) handler for gCTS / AFF format.
+*
+* Note: TABL has no AFF schema in SAP/abap-file-formats — this handler
+* uses a gCTS-compatible shape with formatVersion "1". If AFF adds a TABL
+* schema later, align here.
+*/
+const tableHandler = createHandler(AdkTable, {
+	toMetadata(tabl) {
+		const data = tabl.dataSync;
+		return {
+			formatVersion: "1",
+			header: {
+				description: tabl.description ?? "",
+				originalLanguage: (data.language ?? data.masterLanguage ?? "").toLowerCase()
+			},
+			table: {
+				tableCategory: data.tableCategory,
+				deliveryClass: data.deliveryClass,
+				dataMaintenance: data.dataMaintenance,
+				fields: data.fields
+			}
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta?.header?.description,
+		language: meta?.header?.originalLanguage?.toUpperCase(),
+		masterLanguage: meta?.header?.originalLanguage?.toUpperCase(),
+		tableCategory: meta?.table?.tableCategory,
+		deliveryClass: meta?.table?.deliveryClass,
+		dataMaintenance: meta?.table?.dataMaintenance,
+		fields: meta?.table?.fields
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/ttyp.ts
+/**
+* TTYP (table type) handler for gCTS / AFF format.
+*
+* Note: TTYP has no AFF schema in SAP/abap-file-formats — this handler
+* uses a gCTS-compatible shape with formatVersion "1". If AFF adds a TTYP
+* schema later, align here.
+*/
+const tableTypeHandler = createHandler(AdkTableType, {
+	toMetadata(ttyp) {
+		const data = ttyp.dataSync;
+		return {
+			formatVersion: "1",
+			header: {
+				description: ttyp.description ?? "",
+				originalLanguage: (data.language ?? data.masterLanguage ?? "").toLowerCase()
+			},
+			tableType: {
+				accessMode: data.accessMode,
+				rowType: data.rowTypeRef?.name,
+				primaryKey: data.primaryKey,
+				secondaryKeys: data.secondaryKeys
+			}
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta?.header?.description,
+		language: meta?.header?.originalLanguage?.toUpperCase()
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/fugr.ts
+/**
+* FUGR (function group) handler for gCTS / AFF format.
+*
+* Projects ADK function group data to the AFF fugr-v1.json schema shape:
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     fixPointArithmetic: boolean (required),
+*     status?
+*   }
+*
+* AFF's FUGR representation nests function modules under the group
+* directory. This handler emits the group metadata plus per-function-module
+* files when function module data is available:
+*   <fmname>.func.json — FM metadata (func-v1.json schema)
+*   <fmname>.func.abap — FM source
+*/
+function buildFuncMetadata(fm) {
+	const meta = {
+		formatVersion: "1",
+		header: { description: fm.description ?? fm.name ?? "" },
+		processingType: fm.processingType ?? "normal",
+		includeNumber: fm.includeNumber ?? "0000"
+	};
+	return JSON.stringify(meta, null, 2) + "\n";
+}
+const functionGroupHandler = createHandler(AdkFunctionGroup, {
+	toMetadata(fugr) {
+		const data = fugr.dataSync ?? {};
+		const lang = (data.language ?? data.masterLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: fugr.description ?? "",
+				originalLanguage: lang
+			},
+			fixPointArithmetic: data.fixPointArithmetic === true
+		};
+	},
+	getSource: (fugr) => typeof fugr.getSource === "function" ? fugr.getSource() : "",
+	getExtraFiles(fugr) {
+		const fms = fugr.functionModules ?? [];
+		const files = [];
+		for (const fm of fms) {
+			const fmName = fm.name.toLowerCase();
+			files.push({
+				path: `${fmName}.func.json`,
+				content: buildFuncMetadata(fm)
+			});
+			if (fm.source) files.push({
+				path: `${fmName}.func.abap`,
+				content: fm.source
+			});
+		}
+		return files;
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		fixPointArithmetic: meta.fixPointArithmetic
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/ddls.ts
+/**
+* DDLS (CDS view) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.ddls.asddls` (source) + `<name>.ddls.json`
+* (metadata per ddls-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     sourceOrigin: "abapDevelopmentTools" (required),
+*     sourceType: "unknown" (required),
+*     parentName?: string
+*   }
+*/
+const ddlSourceHandler = createHandler("DDLS", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			},
+			sourceOrigin: obj.sourceOrigin ?? "abapDevelopmentTools",
+			sourceType: obj.sourceType ?? "unknown"
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		sourceOrigin: meta.sourceOrigin,
+		sourceType: meta.sourceType
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/dcls.ts
+/**
+* DCLS (CDS access control) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.dcls.asdcls` (source) + `<name>.dcls.json`
+* (metadata per dcls-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? }
+*   }
+*/
+const dclSourceHandler = createHandler("DCLS", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			}
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase()
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/bdef.ts
+/**
+* BDEF (RAP behavior definition) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.bdef.abdl` (source) + `<name>.bdef.json`
+* (metadata per bdef-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     extendedBehaviorDefintion?: { name?: string }
+*   }
+*/
+const behaviorDefinitionHandler = createHandler("BDEF", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			}
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase()
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/srvd.ts
+/**
+* SRVD (RAP service definition) handler for gCTS / AFF format.
+*
+* Source-driven: emits `<name>.srvd.acds` (source) + `<name>.srvd.json`
+* (metadata per srvd-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     generalInformation: { sourceOrigin, sourceType }
+*   }
+*/
+const serviceDefinitionHandler = createHandler("SRVD", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			},
+			generalInformation: {
+				sourceOrigin: obj.sourceOrigin ?? "abapDevelopmentTools",
+				sourceType: obj.sourceType ?? "definition"
+			}
+		};
+	},
+	getSource: (obj) => typeof obj.getSource === "function" ? obj.getSource() : "",
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		sourceOrigin: meta.generalInformation.sourceOrigin,
+		sourceType: meta.generalInformation.sourceType
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/srvb.ts
+/**
+* SRVB (RAP service binding) handler for gCTS / AFF format.
+*
+* Metadata-only (no source): emits `<name>.srvb.json` only
+* (metadata per srvb-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage, abapLanguageVersion? },
+*     bindingType: string (required),
+*     bindingTypeCategory: "ui" | "webApi" (required),
+*     services: [{ name, versions: [{ serviceVersion, serviceDefinition }] }]
+*   }
+*/
+const serviceBindingHandler = createHandler("SRVB", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang,
+				...obj.abapLanguageVersion ? { abapLanguageVersion: obj.abapLanguageVersion } : {}
+			},
+			bindingType: obj.bindingType ?? "",
+			bindingTypeCategory: obj.bindingTypeCategory ?? "ui",
+			services: obj.services ?? []
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		bindingType: meta.bindingType,
+		bindingTypeCategory: meta.bindingTypeCategory,
+		services: meta.services
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/msag.ts
+/**
+* MSAG (message class) handler for gCTS / AFF format.
+*
+* Metadata-only (no source): emits `<name>.msag.json` only
+* (metadata per msag-v1.json schema).
+*
+*   {
+*     formatVersion: "1",
+*     header: { description, originalLanguage },
+*     messages: [{ number?: string, text?: string }]
+*   }
+*/
+const messageClassHandler = createHandler("MSAG", {
+	toMetadata(obj) {
+		const lang = (obj.originalLanguage ?? "").toLowerCase();
+		return {
+			formatVersion: "1",
+			header: {
+				description: obj.description ?? obj.name ?? "",
+				originalLanguage: lang
+			},
+			messages: obj.messages ?? []
+		};
+	},
+	fromMetadata: (meta) => ({
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase(),
+		messages: meta.messages
+	})
+});
+
+//#endregion
+//#region src/lib/handlers/objects/wave2-generic.ts
+/**
+* Generic AFF handler stubs for the remaining object types.
+*
+* Wave 2 mass-generates handlers for all AFF types that have JSON schemas
+* but no dedicated handler. Each stub emits the minimal AFF contract:
+*   { formatVersion: "1", header: { description, originalLanguage } }
+*
+* Type-specific fields can be added later by promoting a stub to a
+* dedicated handler file (like clas.ts, ddls.ts, etc.) when the ADK
+* object model exposes richer data for that type.
+*
+* All types here are registered via the string-type form of
+* `createHandler` — no ADK class required.
+*/
+function toMetadata(obj) {
+	const lang = (obj.originalLanguage ?? "").toLowerCase();
+	const meta = {
+		formatVersion: "1",
+		header: {
+			description: obj.description ?? obj.name ?? "",
+			originalLanguage: lang
+		}
+	};
+	if (obj.abapLanguageVersion) meta.header.abapLanguageVersion = obj.abapLanguageVersion;
+	return meta;
+}
+function fromMetadata(meta) {
+	return {
+		name: "",
+		description: meta.header.description,
+		language: meta.header.originalLanguage?.toUpperCase(),
+		masterLanguage: meta.header.originalLanguage?.toUpperCase()
+	};
+}
+function getSource(obj) {
+	return typeof obj.getSource === "function" ? obj.getSource() : "";
+}
+for (const type of [
+	"ADVC",
+	"AIFA",
+	"AIFD",
+	"AIFF",
+	"AIFI",
+	"AIFN",
+	"AIFP",
+	"AIFR",
+	"AOBJ",
+	"APIC",
+	"APLO",
+	"APOB",
+	"BGQC",
+	"CDBO",
+	"CFDF",
+	"CHDO",
+	"CHKC",
+	"CHKO",
+	"CHKV",
+	"COTA",
+	"CSNM",
+	"DCAT",
+	"DDLA",
+	"DDLX",
+	"DESD",
+	"DMON",
+	"DOBJ",
+	"DRAS",
+	"DRTY",
+	"DSFD",
+	"DSFI",
+	"DTDC",
+	"DTEB",
+	"DTIX",
+	"DTSC",
+	"EDCC",
+	"EDCK",
+	"EDCR",
+	"EDOI",
+	"EEEC",
+	"ENHO",
+	"ENHS",
+	"ENQU",
+	"EVTB",
+	"EVTO",
+	"GSMP",
+	"HTTP",
+	"ILMB",
+	"INTM",
+	"INTS",
+	"IWNG",
+	"NONT",
+	"NROB",
+	"NTTA",
+	"NTTY",
+	"RONT",
+	"RVBC",
+	"SAIA",
+	"SAJC",
+	"SAJT",
+	"SCP1",
+	"SFPF",
+	"SIAD",
+	"SITO",
+	"SMBC",
+	"SMTG",
+	"SPRV",
+	"SRVC",
+	"SUCO",
+	"SUSI",
+	"SWCR",
+	"SXTG",
+	"UIAD",
+	"UIPG",
+	"UIST"
+]) createHandler(type, {
+	toMetadata,
+	getSource,
+	fromMetadata
+});
+
+//#endregion
+//#region src/lib/format/gcts-format.ts
+const gctsFormatPlugin = {
+	id: "gcts",
+	description: "gCTS / AFF (abap-file-formats) serialization format (JSON metadata + .abap/.acds sources)",
+	get supportedTypes() {
+		return getSupportedTypes();
+	},
+	getHandler(type) {
+		return getHandler(type);
+	},
+	parseFilename(filename) {
+		return parseGctsFilename(filename);
+	}
+};
+
+//#endregion
+//#region src/lib/deserializer.ts
+/** Source-file extensions emitted by gCTS handlers. */
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	"abap",
+	"asddls",
+	"asdcls"
+]);
+/**
+* Map numeric abapLanguageVersion codes (`'5'` etc.) to the descriptive
+* string the ADT REST API expects (`'cloudDevelopment'`). Mirrors the
+* helper in `adt-plugin-abapgit` — kept local so this package does not
+* depend on its sibling.
+*/
+const ABAP_LANG_VER_TO_ADT = {
+	"2": "keyUser",
+	"5": "cloudDevelopment"
+};
+function abapLangVerToAdt(code) {
+	if (!code) return void 0;
+	return ABAP_LANG_VER_TO_ADT[code] ?? code;
+}
+/**
+* Deserialise a gCTS/AFF file tree into `AdkObject` instances.
+*
+* @param fileTree  Virtual FS abstraction (checkin supplies a real-fs impl).
+* @param client    `AdtClient` — required by `createAdk` to build ADK objects.
+* @param options   Export options. `rootPackage` is assigned as packageRef
+*                  to every discovered object that lacks one, mirroring the
+*                  abapGit behaviour when `.abapgit.xml` is absent.
+*/
+async function* deserialize(fileTree, client, options) {
+	const adk = createAdk(client);
+	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: []
+		});
+		objectMap.get(key).metadataFile = jsonPath;
+	}
+	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
+			});
+		}
+	}
+	for (const [, objFiles] of objectMap) {
+		if (!objFiles.metadataFile) continue;
+		const handler = getHandler(objFiles.type);
+		if (!handler) continue;
+		try {
+			const raw = await fileTree.read(objFiles.metadataFile);
+			const metadata = handler.schema.parse(raw);
+			const sources = {};
+			for (const { path, suffix } of objFiles.sourceFiles) {
+				const content = await fileTree.read(path);
+				const sourceKey = suffix ? handler.suffixToSourceKey?.[suffix] ?? suffix : "main";
+				sources[sourceKey] = content;
+			}
+			const payload = handler.fromAbapGit ? handler.fromAbapGit(metadata) : { name: objFiles.name };
+			const objectName = payload.name || objFiles.name;
+			const fullData = {
+				...payload,
+				name: objectName
+			};
+			const adkType = typeof payload.type === "string" ? payload.type : objFiles.type;
+			const adkObject = adk.getWithData(fullData, adkType);
+			if (Object.keys(sources).length > 0) {
+				if (handler.setSources) handler.setSources(adkObject, sources);
+				else if (sources.main) adkObject._pendingSource = sources.main;
+			}
+			if (payload.description) adkObject._pendingDescription = payload.description;
+			adkObject._relDir = objFiles.metadataFile.split("/").slice(0, -1).join("/");
+			if (options?.rootPackage) {
+				const data = adkObject._data;
+				if (data && !data.packageRef) data.packageRef = { name: options.rootPackage };
+			}
+			if (options?.abapLanguageVersion) {
+				const data = adkObject._data;
+				if (data && !data.abapLanguageVersion) data.abapLanguageVersion = abapLangVerToAdt(options.abapLanguageVersion) ?? options.abapLanguageVersion;
+			}
+			yield adkObject;
+		} catch (error) {
+			console.error(`Failed to deserialize ${objFiles.type} ${objFiles.name}:`, error);
+		}
+	}
+}
+
+//#endregion
+//#region src/lib/gcts-plugin.ts
+/**
+* gCTS AdtPlugin.
+*
+* The `FormatPlugin` in `format/gcts-format.ts` provides the declarative
+* contract (used by registry consumers); this `AdtPlugin` provides the
+* behaviour expected by `adt-cli`'s higher-level import/export services.
+*
+* SAP → disk ("import") serialises ADK objects to AFF JSON + source files.
+* Disk → SAP ("export" in adt-cli terminology — Git → SAP direction) is
+* delegated to `./deserializer.ts`, which yields AdkObjects for the
+* `CheckinService` apply pipeline (E08). Together they close the
+* round-trip that the E06 v0.1 follow-ups called out.
+*/
+const gctsPlugin = createPlugin({
+	name: "gcts",
+	version: "0.1.0",
+	description: "gCTS / AFF format plugin — JSON metadata + .abap/.acds sources",
+	registry: {
+		isSupported,
+		getSupportedTypes
+	},
+	format: {
+		async import(object, targetPath, context) {
+			try {
+				const objPackage = object.type?.startsWith("DEVC") ? object.name : object.package || object.name || "ROOT";
+				const packageDir = (await context.resolvePackagePath(objPackage)).map((p) => p.toLowerCase()).join("/");
+				const handler = getHandler(object.type);
+				if (!handler) return {
+					success: false,
+					filesCreated: [],
+					errors: [`No gCTS handler registered for object type: ${object.type}`]
+				};
+				const files = await handler.serialize(object);
+				const baseDir = join(targetPath, "src", packageDir);
+				mkdirSync(baseDir, { recursive: true });
+				const written = [];
+				for (const f of files) {
+					const full = join(baseDir, f.path);
+					mkdirSync(dirname(full), { recursive: true });
+					writeFileSync(full, f.content, f.encoding ?? "utf8");
+					written.push(full);
+				}
+				return {
+					success: true,
+					filesCreated: written
+				};
+			} catch (error) {
+				return {
+					success: false,
+					filesCreated: [],
+					errors: [error instanceof Error ? error.message : String(error)]
+				};
+			}
+		},
+		export: (fileTree, client, options) => deserialize(fileTree, client, options)
+	}
+});
+
+//#endregion
+//#region src/index.ts
+/**
+* @abapify/adt-plugin-gcts — gCTS / AFF format plugin entry point.
+*
+* Importing this module self-registers the plugin into the global
+* `FormatPlugin` registry so that `--format gcts` becomes available
+* throughout the `adt` CLI.
+*/
+registerFormatPlugin(gctsFormatPlugin);
+registerFormatPlugin({
+	...gctsFormatPlugin,
+	id: "aff"
+});
+
+//#endregion
+export { gctsPlugin as GctsPlugin, gctsPlugin as default, gctsPlugin, METADATA_EXTENSION, PACKAGE_FILENAME, adtUriToGctsPath, createHandler, gctsFilename, gctsFormatPlugin, getHandler, getSupportedTypes, isSupported, parseGctsFilename };
+//# sourceMappingURL=index.mjs.map