@abapify/adt-plugin-abapgit 0.4.34 → 0.4.38

package/README.md

@@ -1,191 +1,40 @@
 # @abapify/adt-plugin-abapgit
 
-[![version](https://img.shields.io/github/package-json/v/abapify/adt-cli?filename=packages/adt-plugin-abapgit/package.json)](https://github.com/abapify/adt-cli/pkgs/npm/%40abapify%2Fadt-plugin-abapgit)
+[![npm](https://img.shields.io/npm/v/%40abapify%2Fadt-plugin-abapgit)](https://www.npmjs.com/package/@abapify/adt-plugin-abapgit)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/abapify/adt-cli/blob/main/LICENSE)
 
-abapGit format plugin for ADT — serializes ABAP objects to Git-compatible XML/ABAP files.
+abapGit serialization plugin for adt-cli — round-trips ADT objects to/from the abapGit on-disk format.
 
-## Pure materialization
+## Install
 
-The registered `abapgitFormatPlugin` can produce a desired object tree without
-filesystem, ADT, or Git side effects. Explicit source components override
-mutable ADK source getters, while existing XSD-backed handlers continue to
-produce metadata:
+```bash
+npm install @abapify/adt-plugin-abapgit
+```
+
+## Usage
+
+```ts
+import { abapgitFormatPlugin } from '@abapify/adt-plugin-abapgit';
 
-```typescript
 const { files } = await abapgitFormatPlugin.materialize({
   object: adkClass,
   objectType: 'CLAS',
-  packagePath: ['ZROOT', 'ZROOT_FEATURE'],
-  sources: {
-    main: selectedMainSource,
-    definitions: selectedLocalDefinitions,
-  },
+  packagePath: ['ZROOT'],
+  sources: { main: source },
   formatOptions: { folderLogic: 'prefix' },
 });
 ```
 
-Paths are rooted below `src/`, ordered deterministically, and annotated with
-their semantic role and source-component identity. Existing filesystem import
-and Git-to-SAP export APIs remain unchanged.
-
-## Architecture Overview
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                        adt-plugin-abapgit                           │
-├─────────────────────────────────────────────────────────────────────┤
-│  XSD Schemas (xsd/)          →  ts-xsd codegen  →  TypeScript types │
-│  (XML structure definition)     (build time)       + parser/builder │
-├─────────────────────────────────────────────────────────────────────┤
-│  Object Handlers (handlers/)                                        │
-│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │
-│  │  CLAS   │ │  INTF   │ │  DEVC   │ │  DTEL   │ │  DOMA   │       │
-│  │ handler │ │ handler │ │ handler │ │ handler │ │ handler │       │
-│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘       │
-│       └──────────┬┴──────────┬┴──────────┬┴──────────┘             │
-│                  ▼           ▼           ▼                          │
-│            createHandler (factory)                                  │
-│            - Auto-registration                                      │
-│            - Default serialize logic                                │
-│            - File naming conventions                                │
-├─────────────────────────────────────────────────────────────────────┤
-│  ADK Facade (@abapify/adk)                                          │
-│  - AdkClass, AdkInterface, AdkPackage...                            │
-│  - Client-agnostic object model                                     │
-│  - Source code retrieval via getSource()/getIncludeSource()         │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
-## Key Design Decisions
-
-### 1. XSD Schemas as Single Source of Truth
-
-**Why XSD?**
-
-- XML Schema Definition (XSD) is the **industry standard** for XML structure validation
-- Can be used **outside our tools** (e.g., `xmllint --schema intf.xsd file.xml`)
-- Provides **formal contract** for abapGit XML format
-- Enables **automated validation** in CI/CD pipelines
-
-```bash
-# Validate any abapGit XML file against our schema
-xmllint --schema xsd/intf.xsd myinterface.intf.xml --noout
-```
-
-### 2. ts-xsd for Type-Safe XML Handling
-
-**Why ts-xsd?**
-
-Unlike typical XML codegen tools that only generate types, `ts-xsd` provides:
-
-- **TypeScript types** with full type inference
-- **XML parser** that returns typed objects
-- **XML builder** that accepts typed objects
-- **Schema object** for runtime validation
-
-```typescript
-// Generated from XSD - fully typed parse/build
-import { intf } from './schemas/generated';
-
-const data = intf.parse(xmlString); // → AbapGitIntf (typed)
-const xml = intf.build(data); // → string (valid XML)
-```
-
-### 3. ADK as Client-Agnostic Facade
-
-**Why not implement ADT client features in the plugin?**
-
-The plugin **only consumes** the ADK facade:
-
-- ADK handles all SAP communication details
-- Plugin focuses purely on **serialization format**
-- Same plugin works with any ADT client implementation
-- Clear separation of concerns
-
-```typescript
-// Plugin receives ADK objects, doesn't care how they were fetched
-getSources: (cls) =>
-  cls.includes.map((inc) => ({
-    suffix: ABAPGIT_SUFFIX[inc.includeType],
-    content: cls.getIncludeSource(inc.includeType), // ADK handles this
-  }));
-```
-
-### 4. Handlers Don't Touch File System
-
-**Why delegate file operations to base class?**
-
-Object handlers **only define mappings**:
-
-- `toAbapGit()` - ADK data → abapGit XML structure
-- `getSource()` / `getSources()` - which source files to create
-
-The `createHandler` factory handles:
-
-- File creation with correct naming
-- XML building with proper envelope
-- Promise resolution for async sources
-- Empty content filtering
-
-## Supported Object Types
-
-| Type | Status | Handler   | Notes                                                                 |
-| ---- | ------ | --------- | --------------------------------------------------------------------- |
-| CLAS | ✅     | `clas.ts` | Multiple includes (main, locals_def, locals_imp, testclasses, macros) |
-| INTF | ✅     | `intf.ts` | Single source file                                                    |
-| DEVC | ✅     | `devc.ts` | Fixed filename `package.devc.xml`                                     |
-| DTEL | ✅     | `dtel.ts` | Metadata only (no source)                                             |
-| DOMA | ✅     | `doma.ts` | Custom serialize for fixed values                                     |
-
-## File Structure
-
-```
-src/
-├── zcl_example.clas.abap              # Main class source
-├── zcl_example.clas.locals_def.abap   # Local type definitions
-├── zcl_example.clas.locals_imp.abap   # Local implementations
-├── zcl_example.clas.testclasses.abap  # Test classes
-├── zcl_example.clas.xml               # Class metadata
-├── zif_example.intf.abap              # Interface source
-├── zif_example.intf.xml               # Interface metadata
-├── ztest_dtel.dtel.xml                # Data element (no source)
-├── ztest_doma.doma.xml                # Domain (no source)
-└── package.devc.xml                   # Package definition
-```
-
-## Development
-
-### Building
-
-```bash
-npx nx build adt-plugin-abapgit
-```
-
-### Testing
-
-```bash
-npx nx test adt-plugin-abapgit
-```
-
-### Regenerating Schemas
-
-After modifying XSD files:
-
-```bash
-npx nx codegen adt-plugin-abapgit
-```
+## Features
 
-## Contributing
+- Round-trips ADT objects to / from the abapGit on-disk format
+- `prefix` and `full` folder logic
+- Used by `adt checkout` / `adt checkin`
 
-See [CONTRIBUTING.md](./CONTRIBUTING.md) for detailed guidelines on:
+## Documentation
 
-- Adding new object type support
-- XSD schema conventions
-- Handler implementation patterns
-- Testing requirements
+**[adt-cli.netlify.app/sdk/packages/adt-plugin-abapgit](https://adt-cli.netlify.app/sdk/packages/adt-plugin-abapgit)**
 
-## See Also
+---
 
-- [abapGit Documentation](https://docs.abapgit.org/)
-- [@abapify/adt-plugin](../adt-plugin/README.md) - Plugin interface
-- [@abapify/adk](../adk/README.md) - ABAP Development Kit
+Part of [**abapify**](https://github.com/abapify/adt-cli) — open, typed tooling for SAP ABAP Development Tools (ADT): CLI, MCP server, and SDK.

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AbapObjectType, AdtPlugin, AdtPlugin as AdtPlugin$1, ExportContext, ExportResult, FormatMaterializationInput, FormatMaterializationResult, FormatPlugin, FormatSerializeOptions, ImportContext, ImportResult, MaterializedFormatFile } from "@abapify/adt-plugin";
+import { AdtPlugin, AdtPlugin as AdtPlugin$1, ExportContext, ExportResult, FormatMaterializationInput, FormatMaterializationResult, FormatPlugin, FormatSerializeOptions, ImportContext, ImportResult, MaterializedFormatFile } from "@abapify/adt-plugin";
 import { AdkObject } from "@abapify/adk";
 import { SchemaLike, TypedSchema } from "@abapify/ts-xsd";
 import { adtUriToAbapGitPath, createAbapGitResolver as createFindingResolver } from "@abapify/adt-atc";
@@ -70,11 +70,9 @@ type InferValuesType<S> = S extends AbapGitSchema<unknown, infer V> ? V : unknow
  * Extract the data type (D) from an AdkObject<K, D>
  * This allows us to infer the payload type from the ADK class itself
  */
-type InferAdkData<T> = T extends AdkObject<infer _K, infer D> ? D : never;
-/**
- * ABAP object type code (e.g., 'CLAS', 'INTF', 'DOMA')
- */
-type AbapObjectType$1 = string;
+type InferAdkData<T> = T extends AdkObject<infer _K, infer D> ? D : keyof T extends keyof HandlerObject ? Record<string, unknown> : T;
+/** Identity shared by ADK instances and string-type handler facades. */
+type HandlerObject = Pick<AdkObject, 'name'>;
 /**
  * Result of serializing a single file
  */
@@ -92,9 +90,9 @@ interface SerializedFile {
  * @typeParam T - ADK object type
  * @typeParam TSchema - AbapGit schema type (provides type-safe values)
  */
-interface ObjectHandler<T extends AdkObject = AdkObject, TSchema extends AbapGitSchema<unknown, unknown> = AbapGitSchema<unknown, unknown>> {
+interface ObjectHandler<T extends HandlerObject = AdkObject, TSchema extends AbapGitSchema<unknown, unknown> = AbapGitSchema<unknown, unknown>> {
   /** ABAP object type (e.g., 'CLAS', 'INTF') */
-  readonly type: AbapObjectType$1;
+  readonly type: string;
   /** File extension for this type (e.g., 'clas', 'intf') */
   readonly fileExtension: string;
   /** Schema for parsing/building XML */
@@ -133,17 +131,17 @@ interface ObjectHandler<T extends AdkObject = AdkObject, TSchema extends AbapGit
  * main type (e.g., 'CLAS/OC' → 'CLAS'). This matches ADK's resolveType()
  * behaviour and handles quickSearch results that return subtypes.
  */
-declare function getHandler(type: AbapObjectType$1): ObjectHandler | undefined;
+declare function getHandler(type: string): ObjectHandler<HandlerObject> | undefined;
 /**
  * Check if object type is supported
  *
  * Tries the full type first, then falls back to the main type.
  */
-declare function isSupported(type: AbapObjectType$1): boolean;
+declare function isSupported(type: string): boolean;
 /**
  * Get all supported object types
  */
-declare function getSupportedTypes(): AbapObjectType$1[];
+declare function getSupportedTypes(): string[];
 /**
  * abapGit filename parsing utilities.
  *
@@ -206,5 +204,5 @@ declare function moveNamespaceToAbap(xml: string): string;
  * 2. Move xmlns:asx to asx:abap element
  */
 declare function formatAbapGitXml(xml: string): string;
-export { abapGitPlugin as AbapGitPlugin, abapGitPlugin, abapGitPlugin as default, type AbapObjectType, type AdtPlugin, type ExportContext, type ExportResult, type FolderLogic, type FormatMaterializationInput, type FormatMaterializationResult, type ImportContext, type ImportResult, type MaterializedFormatFile, type ObjectHandler, type SerializedFile, abapgitFormatPlugin, adtUriToAbapGitPath, createFindingResolver, formatAbapGitXml, formatXmlAttributes, getHandler, getSupportedTypes, isSupported, moveNamespaceToAbap, parseAbapGitFilename, parseAbapGitMetadata, resolvePackageFromDir, reverseResolveRootPackage };
+export { abapGitPlugin as AbapGitPlugin, abapGitPlugin, abapGitPlugin as default, type AdtPlugin, type ExportContext, type ExportResult, type FolderLogic, type FormatMaterializationInput, type FormatMaterializationResult, type ImportContext, type ImportResult, type MaterializedFormatFile, type ObjectHandler, type SerializedFile, abapgitFormatPlugin, adtUriToAbapGitPath, createFindingResolver, formatAbapGitXml, formatXmlAttributes, getHandler, getSupportedTypes, isSupported, moveNamespaceToAbap, parseAbapGitFilename, parseAbapGitMetadata, resolvePackageFromDir, reverseResolveRootPackage };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["AdtPlugin","AbapObjectType"],"sources":["../src/lib/format-plugin.ts","../src/lib/folder-logic.ts","../src/lib/abapgit.ts","../src/lib/handlers/abapgit-schema.ts","../src/lib/handlers/base.ts","../src/lib/filename-parser.ts","../src/lib/handlers/xml-format.ts"],"mappings":";;;;cAgGa,qBAAqB;;;;;;;;;KCvFtB;;;;iBA6CI,qBAAqB;EACnC,aAAa;EACb;;;;;;;;;;;;;;;;iBAsBc,sBACd,iBACA,aAAa,aACb;;;;;;;;;;;;;iBA2Cc,0BACd,oBACA,gBACA,aAAa;;;;;;cC2EF,eAAeA;;;;;;;;UCrLX,cACf,OACA,SACA,UAAU,aAAa,oBACf,YAAY,OAAO;;WAElB,SAAS;;;KA2CR,gBAAgB,KAC1B,UAAU,6BAA6B,KAAK;;;;;KC/ClC,aAAa,KACvB,UAAU,gBAAgB,UAAU,KAAK;;;;KAsB/BC;;;;UAKK;;EAEf;;EAEA;;EAEA,WAAW;;;;;;;;UASI,cACf,UAAU,YAAY,WACtB,gBAAgB,kCAAkC;;WAMzC,MAAMA;;WAEN;;WAEA,QAAQ;;WAER,oBAAoB;;WAEpB;;EAET,UACE,QAAQ,GACR,UAAU,yBACT,QAAQ;;;;;EAKX,aACE,QAAQ,gBAAgB,WACvB,QAAQ,aAAa;IAAQ;;;;;;;EAOhC,aAAa,MAAM,0BAA0B,QAAQ,aAAa;IAChE;;;;;;EAOF,YAAY,QAAQ,GAAG,SAAS;;;;;;;;;iBAyBlB,WAAW,MAAMA,mBAAiB;;;;;;iBASlC,YAAY,MAAMA;;;;iBAOlB,qBAAqBA;;;;;;;;;;;;;;;;;;;;;iBCjIrB,qBAAqB;EACnC;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;iBC+Bc,oBAAoB;;;;;;;iBA8DpB,oBAAoB;;;;;;iBA8BpB,iBAAiB"}
+{"version":3,"file":"index.d.mts","names":["AdtPlugin"],"sources":["../src/lib/format-plugin.ts","../src/lib/folder-logic.ts","../src/lib/abapgit.ts","../src/lib/handlers/abapgit-schema.ts","../src/lib/handlers/base.ts","../src/lib/filename-parser.ts","../src/lib/handlers/xml-format.ts"],"mappings":";;;;cAiGa,qBAAqB;;;;;;;;;KCxFtB;;;;iBA6CI,qBAAqB;EACnC,aAAa;EACb;;;;;;;;;;;;;;;;iBAsBc,sBACd,iBACA,aAAa,aACb;;;;;;;;;;;;;iBA2Cc,0BACd,oBACA,gBACA,aAAa;;;;;;cC2EF,eAAeA;;;;;;;;UCrLX,cACf,OACA,SACA,UAAU,aAAa,oBACf,YAAY,OAAO;;WAElB,SAAS;;;KA2CR,gBAAgB,KAC1B,UAAU,6BAA6B,KAAK;;;;;KC/ClC,aAAa,KACvB,UAAU,gBAAgB,UAAU,KAChC,UACM,gBAAgB,gBACpB,0BACA;;KAGI,gBAAgB,KAAK;;;;UAsBhB;;EAEf;;EAEA;;EAEA,WAAW;;;;;;;;UASI,cACf,UAAU,gBAAgB,WAC1B,gBAAgB,kCAAkC;;WAMzC;;WAEA;;WAEA,QAAQ;;WAER,oBAAoB;;WAEpB;;EAET,UACE,QAAQ,GACR,UAAU,yBACT,QAAQ;;;;;EAKX,aACE,QAAQ,gBAAgB,WACvB,QAAQ,aAAa;IAAQ;;;;;;;EAOhC,aAAa,MAAM,0BAA0B,QAAQ,aAAa;IAChE;;;;;;EAOF,YAAY,QAAQ,GAAG,SAAS;;;;;;;;;iBAyBlB,WACd,eACC,cAAc;;;;;;iBASD,YAAY;;;;iBAOZ;;;;;;;;;;;;;;;;;;;;;iBCrIA,qBAAqB;EACnC;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;iBC+Bc,oBAAoB;;;;;;;iBA8DpB,oBAAoB;;;;;;iBA8BpB,iBAAiB"}