@mcp-abap-adt/interfaces-adt 1.0.0

package/dist/adt/IAdtUtilities.d.ts

@@ -0,0 +1,310 @@
+/**
+ * The cross-cutting ADT operations, split by the resource families ADT itself
+ * has — not by which of them a particular system refuses.
+ *
+ * `AdtUtils` in `@mcp-abap-adt/adt-clients` is one class with 28 public methods,
+ * handed out by `AdtClient.getUtils()` as itself. A concrete return is the one a
+ * consumer cannot substitute, cannot compose with their own types, and cannot
+ * have checked at the factory — see decision 12 here and decision 10 there.
+ *
+ * **The grain comes from ADT's own resource space**, read out of the endpoints
+ * the implementation calls:
+ *
+ * | family | atom |
+ * |---|---|
+ * | `/repository/informationsystem/*` | {@link IAdtInformationSystem} |
+ * | `/repository/nodestructure`, `/repository/objectstructure` | {@link IAdtRepositoryStructure} |
+ * | `/activation`, `/deletion` | {@link IAdtGroupLifecycle} |
+ * | `/datapreview/*` | {@link IAdtDataPreview} |
+ * | `/discovery` | {@link IAdtDiscovery} |
+ * | the per-type resources — `oo`, `programs`, `ddic`, `functions`, `enhancements` | {@link IAdtObjectAccess} |
+ *
+ * Deliberately *not* the grain a measurement suggested. When this split was
+ * chosen, the one legacy implementation refused exactly `getSqlQuery`,
+ * `getTableContents` and `getTransaction` — which would have given three atoms
+ * and a bag of 28. Those refusals fall **inside** these families rather than
+ * defining them, so architecture and observation agree; observation is simply
+ * narrower, and a contract split by who refuses what is a contract that changes
+ * shape with the next system.
+ *
+ * Removing `getTransaction` made that concrete rather than theoretical. The
+ * legacy implementation now refuses two members, and **both are
+ * {@link IAdtDataPreview}** — a whole family, refused whole, which is what a
+ * split along ADT's resources predicts and a split along refusals could not have
+ * known in advance. Had the atoms been drawn from the observation, one of the
+ * three would have evaporated when its member did.
+ *
+ * A few members compute a string and issue no request — `supportsSourceCode`,
+ * `getObjectSourceUri`, `modifyWhereUsedScope`. They stay with the family whose
+ * requests they prepare, because a consumer replacing that family needs them to
+ * build the same call.
+ *
+ * ## The gap, named rather than papered over
+ *
+ * **Every member states its result.** Twelve of the twenty-five answered
+ * `IAdtWireResponse` — the transport envelope, which every method could name and
+ * which told a consumer only that a request happened. They now answer the
+ * document their endpoint produced, and parsing it is the consumer's (decision
+ * 5). The other thirteen already stated what the caller gets.
+ *
+ * Counted as **members**, not signatures: `search` has two, because one endpoint
+ * is one member (decision 16) and the second signature is the strategy, not a
+ * second capability. A parser that counts signatures reports 26 and is not
+ * wrong about anything except the word.
+ *
+ *
+ * Six were removed because nobody calls them — `getTypeInfo`, `getTransaction`,
+ * `getBdef`, `getEnhancements`, `getEnhancementSpot`, `getEnhancementImpl`. Every
+ * mention of them across the sibling repositories was their own doc comment.
+ * The question was never which result they promise, but why they were in a
+ * contract; three of them were a second door to a handler that was already
+ * there — `getBdef` to `getBehaviorDefinition().read()`, `getEnhancementImpl`
+ * and `getEnhancementSpot` to `getEnhancement()` — and the other three named
+ * resources nothing else reaches. Deleted in `@mcp-abap-adt/adt-clients` with
+ * those three endpoints recorded, so a typed handler can be built where one is
+ * wanted rather than a generic member kept in case one is.
+ *
+ * Two were closed from evidence rather than measurement: `getAllTypes` answers
+ * the named-item list a trace catalogue answers with, and
+ * `fetchNodeStructure` answers objects plus the typed child nodes to walk next.
+ * Both shapes were lifted from parsers that have been reading those documents in
+ * `mcp-abap-adt` against real systems — code that works is evidence; a shape
+ * nobody has read is not.
+ *
+ * Evidence is not the same as being finished. `fetchNodeStructure` first shipped
+ * carrying the ids alone, which cannot say *which* node holds a given type, and
+ * 27.0.0 is that correction — found by a consumer trying to walk with it.
+ *
+ * The twelve are left as they are, deliberately. Closing them means naming what
+ * each endpoint sends, and 12 shapes would have to be named,
+ * and nothing but a capture can name them, which decision 1 forbids. **A strategy does not close them
+ * either** — handing the caller a parser makes the caller decide what comes
+ * back, and the point of a contract is that the consumer is not rewritten when
+ * the implementation changes. Strategy and result contract are different planes;
+ * an attempt to use one for the other cost every implementer two signatures per
+ * method before it was reverted.
+ *
+ * So they close one at a time, on captures. Until then this file states what a
+ * consumer gets for 13 members and admits the gap for 12, which is the honest
+ * shape of the thing rather than a finished one.
+ */
+import type { IReadOptions } from '../shared/IReadOptions';
+import type { IAdtResponse } from './IAdtResponse';
+import type { AdtObjectType, AdtSourceObjectType, IGetDiscoveryParams, IGetSqlQueryParams, IGetTableContentsParams, IGetVirtualFoldersContentsParams, IGetWhereUsedParams, IGetWhereUsedScopeParams, IObjectReference, ISearchObjectsParams } from './IAdtShared';
+/**
+ * `/sap/bc/adt/repository/informationsystem/*` — everything ADT answers about
+ * *where* something is: what exists, what uses it, and what the repository will
+ * show under a filter.
+ *
+ * **Four endpoints, so four atoms.** This was one interface until 40.0.0, and
+ * bundling them meant an implementation that offered three of the four could
+ * declare none of them. That is what happened: a where-used member that issued
+ * *two* requests — the scope, then the search — left `adt-clients` under the
+ * one-member-one-endpoint rule, and taking it out of a bundle would have
+ * dropped `search` and the scope members with it, which are single requests and
+ * staying.
+ *
+ * The composite below still exists and still means what it meant, so an
+ * implementation offering all four writes one name.
+ */
+export interface IAdtInformationSystem<TSearch, TWhereUsed, TScope, TFolders, TTypes> extends IAdtObjectSearch<TSearch>, IAdtWhereUsed<TWhereUsed, TScope>, IAdtVirtualFolders<TFolders>, IAdtTypeCatalogue<TTypes> {
+}
+/**
+ * `/informationsystem/search` — objects matching a query.
+ *
+ * **Not `IAdtSearchable`.** That name was removed in 30.0.0 and meant something
+ * else: an atom a per-object handler declared, which was wrong because
+ * searching is not something an object does to itself. This is the information
+ * system's own member, split out of the bundle so an implementation can offer
+ * it without offering the where-used pair.
+ */
+export interface IAdtObjectSearch<TSearch> {
+    /**
+     * Objects matching a query.
+     *
+     * One signature. Until 30.0.0 a second overload took
+     * `parse: (data: unknown) => T` so a caller could keep the document — a
+     * recorded hit list runs to 473 rows and 1.3MB, with nested references
+     * a parsed hit list deliberately does not carry. That reading is still
+     * available and is now chosen the way every other reading is: an
+     * {@link IResultStrategy} given to the implementation, with `TSearch`
+     * following it.
+     *
+     * Decision 20 — choice is offered by injection, never by more contract — and
+     * decision 22, which says where the injection happens. A per-call argument is
+     * a second signature every implementer pays for whether or not their callers
+     * use it.
+     */
+    search(criteria: ISearchObjectsParams): Promise<IAdtResponse<TSearch>>;
+}
+/**
+ * `/informationsystem/usageReferences` and its `scope` sub-resource.
+ *
+ * **Two requests, two members, and the caller joins them.** A run that wants a
+ * narrowed scope fetches the scope document, edits it, and passes it to the
+ * search. There is no member that does all three: the order, and what to do
+ * when the `scope` sub-resource is absent — some systems answer it `404` — are
+ * decisions that belong to whoever is asking, not to a client that would have
+ * to guess a fallback.
+ */
+export interface IAdtWhereUsed<TWhereUsed, TScope> {
+    /** Where an object is used. One request. */
+    getWhereUsed(params: IGetWhereUsedParams): Promise<IAdtResponse<TWhereUsed>>;
+    /** The scope document a where-used run is filtered by. */
+    getWhereUsedScope(params: IGetWhereUsedScopeParams): Promise<IAdtResponse<TScope>>;
+    /**
+     * That scope document, edited. Issues no request — it rewrites the XML the
+     * call above returned, and belongs here because nothing else can use it.
+     */
+    modifyWhereUsedScope(scopeXml: string, options: {
+        enableAll?: boolean;
+        enableOnly?: string[];
+        enable?: string[];
+        disable?: string[];
+    }): string;
+}
+/** `/informationsystem/virtualfolders` — the repository as folders. */
+export interface IAdtVirtualFolders<TFolders> {
+    /** The repository as folders, under a preselection. */
+    getVirtualFoldersContents(params: IGetVirtualFoldersContentsParams): Promise<IAdtResponse<TFolders>>;
+}
+/** `/informationsystem/objecttypes` — the types this system knows. */
+export interface IAdtTypeCatalogue<TTypes> {
+    /**
+     * The object types this system knows.
+     *
+     * `nameditem:namedItemList` — the same document a trace catalogue serves from
+     * a different resource, so an implementation that reads one reads the other.
+     * Measured against real systems rather than invented; the shape itself is the
+     * implementation's since 31.0.0.
+     */
+    getAllTypes(maxItemCount?: number, name?: string, data?: string): Promise<IAdtResponse<TTypes>>;
+}
+/**
+ * `/sap/bc/adt/repository/nodestructure` and `/objectstructure` — the tree, and
+ * one object's place in it.
+ */
+export interface IAdtRepositoryStructure<TNode, TObjectStructure> {
+    /**
+     * Children of a node: the objects it holds, and the nodes below it.
+     *
+     * Both halves come from one document — `SEU_ADT_REPOSITORY_OBJ_NODE` entries
+     * and the `SEU_ADT_OBJECT_TYPE_INFO` pairs a caller walks next — and a
+     * consumer needs both to traverse, which is why the result names them rather
+     * than handing back the envelope. Lifted from a traversal running in
+     * `mcp-abap-adt`.
+     *
+     * The child half is pairs, not ids: an id on its own cannot answer "which node
+     * holds the includes", which is the question a walk asks. That is a property
+     * an implementation's reading must keep — the shape that used to state it left
+     * in 31.0.0.
+     *
+     * **`withShortDescriptions` reaches the wire, so it is a parameter** (decision
+     * 17). What no *result* has ever carried is a description — every parser that
+     * has read this document reads exactly four identity fields. A consumer who
+     * needs a description supplies an
+     * {@link IResultStrategy} that reads it, which is what `TNode` is for;
+     * inventing a `description?: string` field nobody has captured is what
+     * decision 1 forbids.
+     *
+     * **What this is for.** The node structure asked for as itself — a class's
+     * includes, a program's parts, a package's contents, a node walked by hand.
+     * It answers one level; walking further is the caller's, one call per level,
+     * because a member that walked could never be given a reading.
+     */
+    fetchNodeStructure(parentType: string, parentName: string, options?: IGetNodeContentsOptions): Promise<IAdtResponse<TNode>>;
+    /** The parts one object is made of. */
+    getObjectStructure(objectType: string, objectName: string): Promise<IAdtResponse<TObjectStructure>>;
+}
+/**
+ * What the node-structure request itself takes.
+ *
+ * `node_id` selects a sub-node of the parent; without it the server answers the
+ * parent's own level. Both reach the wire (decision 17), which is why they are
+ * here and a traversal depth is not.
+ */
+export interface IGetNodeContentsOptions {
+    nodeId?: string;
+    withShortDescriptions?: boolean;
+}
+/**
+ * `/sap/bc/adt/activation` and `/sap/bc/adt/deletion` — operations ADT takes on
+ * a set of objects at once, rather than on one.
+ */
+export interface IAdtGroupLifecycle<TInactive, TActivation, TRun, TResults, TDeletionCheck, TDeletion> {
+    /** Activate several objects in one request. */
+    activateObjectsGroup(objects: IObjectReference[], preauditRequested?: boolean): Promise<IAdtResponse<TActivation>>;
+    /**
+     * What an activation run is doing — `/activation/runs/{runId}`.
+     *
+     * One request. `withLongPolling` reaches the wire — the server holds the
+     * request open rather than answering at once — so it is a parameter, not a
+     * reading (decision 17). Which value of `runs:status` ends a wait is the
+     * caller's to decide, and how long to wait is theirs to write.
+     */
+    getActivationRun(runId: string, options?: {
+        withLongPolling?: boolean;
+    }): Promise<IAdtResponse<TRun>>;
+    /** What that run produced — `/activation/results/{runId}`. */
+    getActivationResults(runId: string): Promise<IAdtResponse<TResults>>;
+    /**
+     * What is inactive right now.
+     *
+     * **No `includeRawXml`.** A boolean that changes what the result *is* is a
+     * reading chosen at the call site, which is the shape decisions 16 and 20 rule
+     * out — and it could offer exactly two readings, chosen by whoever wrote the
+     * flag. `TInactive` spans the space instead, following the
+     * {@link IResultStrategy} the implementation was constructed with.
+     */
+    getInactiveObjects(): Promise<IAdtResponse<TInactive>>;
+    /** Whether a set can be deleted, asked before deleting it. */
+    checkDeletionGroup(objects: IObjectReference[]): Promise<IAdtResponse<TDeletionCheck>>;
+    /** Delete several objects in one request. */
+    deleteObjectsGroup(objects: IObjectReference[], transportRequest?: string): Promise<IAdtResponse<TDeletion>>;
+}
+/** `/sap/bc/adt/datapreview/*` — reading data rather than definitions. */
+export interface IAdtDataPreview<TQuery, TColumns, TContents> {
+    /** A freestyle SQL query. */
+    getSqlQuery(params: IGetSqlQueryParams): Promise<IAdtResponse<TQuery>>;
+    /** The rows of one table. */
+    /**
+     * The columns a DDIC entity has — `/datapreview/ddic/{name}/metadata`.
+     *
+     * One request. It exists because the member below no longer makes it: the
+     * statement is the caller's, and this is where they learn what they may name
+     * in it.
+     */
+    getTableColumns(tableName: string): Promise<IAdtResponse<TColumns>>;
+    /**
+     * Rows from a DDIC entity — `/datapreview/ddic`.
+     *
+     * One request: the statement in `params.sql_query` is posted as given. Until
+     * 42.0.0 this read the entity's metadata first and built the statement from
+     * every column it found, which is a choice the caller could not reach.
+     */
+    getTableContents(params: IGetTableContentsParams): Promise<IAdtResponse<TContents>>;
+}
+/** `/sap/bc/adt/discovery` — what this system says it serves. */
+export interface IAdtDiscovery<TDiscovery> {
+    discovery(params?: IGetDiscoveryParams): Promise<IAdtResponse<TDiscovery>>;
+}
+/**
+ * The per-type resources — `oo`, `programs`, `ddic`, `functions`,
+ * `enhancements` — reached generically, by type and name.
+ *
+ * This is what a caller uses when the type is a value rather than a decision:
+ * the typed handlers on `AdtClient` are for when it is known at the call site.
+ */
+export interface IAdtObjectAccess<TSource, TMetadata, TInclude> {
+    /** Source of any object that has source. */
+    readObjectSource(objectType: AdtSourceObjectType, objectName: string, functionGroup?: string, version?: 'active' | 'inactive', options?: IReadOptions): Promise<IAdtResponse<TSource>>;
+    /** Metadata of any object. */
+    readObjectMetadata(objectType: AdtObjectType, objectName: string, functionGroup?: string, options?: IReadOptions): Promise<IAdtResponse<TMetadata>>;
+    /** Whether that type has source at all. Issues no request. */
+    supportsSourceCode(objectType: AdtObjectType): boolean;
+    /** The URI the source read would use. Issues no request. */
+    getObjectSourceUri(objectType: AdtSourceObjectType, objectName: string, functionGroup?: string, version?: 'active' | 'inactive'): string;
+    /** A standalone include. */
+    getInclude(includeName: string): Promise<IAdtResponse<TInclude>>;
+}
+//# sourceMappingURL=IAdtUtilities.d.ts.map

package/dist/adt/IAdtUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtUtilities.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtUtilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EACV,aAAa,EACb,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,EACvB,gCAAgC,EAChC,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,qBAAqB,CACpC,OAAO,EACP,UAAU,EACV,MAAM,EACN,QAAQ,EACR,MAAM,CACN,SAAQ,gBAAgB,CAAC,OAAO,CAAC,EAC/B,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,EACjC,kBAAkB,CAAC,QAAQ,CAAC,EAC5B,iBAAiB,CAAC,MAAM,CAAC;CAAG;AAEhC;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO;IACvC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;CACxE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa,CAAC,UAAU,EAAE,MAAM;IAC/C,4CAA4C;IAC5C,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;IAE7E,0DAA0D;IAC1D,iBAAiB,CACf,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAEjC;;;OAGG;IACH,oBAAoB,CAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;QACP,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,GACA,MAAM,CAAC;CACX;AAED,uEAAuE;AACvE,MAAM,WAAW,kBAAkB,CAAC,QAAQ;IAC1C,uDAAuD;IACvD,yBAAyB,CACvB,MAAM,EAAE,gCAAgC,GACvC,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;CACpC;AAED,sEAAsE;AACtE,MAAM,WAAW,iBAAiB,CAAC,MAAM;IACvC;;;;;;;OAOG;IACH,WAAW,CACT,YAAY,CAAC,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB,CAAC,KAAK,EAAE,gBAAgB;IAC9D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,kBAAkB,CAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IAEhC,uCAAuC;IACvC,kBAAkB,CAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC;CAC5C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB,CACjC,SAAS,EACT,WAAW,EACX,IAAI,EACJ,QAAQ,EACR,cAAc,EACd,SAAS;IAET,+CAA+C;IAC/C,oBAAoB,CAClB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,iBAAiB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC;IAEtC;;;;;;;OAOG;IACH,gBAAgB,CACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IAE/B,8DAA8D;IAC9D,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;IAErE;;;;;;;;OAQG;IACH,kBAAkB,IAAI,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;IAEvD,8DAA8D;IAC9D,kBAAkB,CAChB,OAAO,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,CAAC;IAEzC,6CAA6C;IAC7C,kBAAkB,CAChB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;CACrC;AAED,0EAA0E;AAC1E,MAAM,WAAW,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS;IAC1D,6BAA6B;IAC7B,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvE,6BAA6B;IAC7B;;;;;;OAMG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEpE;;;;;;OAMG;IACH,gBAAgB,CACd,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;CACrC;AAED,iEAAiE;AACjE,MAAM,WAAW,aAAa,CAAC,UAAU;IACvC,SAAS,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;CAC5E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ;IAC5D,4CAA4C;IAC5C,gBAAgB,CACd,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,EAC/B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAElC,8BAA8B;IAC9B,kBAAkB,CAChB,UAAU,EAAE,aAAa,EACzB,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;IAEpC,8DAA8D;IAC9D,kBAAkB,CAAC,UAAU,EAAE,aAAa,GAAG,OAAO,CAAC;IAEvD,4DAA4D;IAC5D,kBAAkB,CAChB,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,GAC9B,MAAM,CAAC;IAEV,4BAA4B;IAC5B,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;CAiBlE"}

package/dist/adt/IAdtUtilities.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * The cross-cutting ADT operations, split by the resource families ADT itself
+ * has — not by which of them a particular system refuses.
+ *
+ * `AdtUtils` in `@mcp-abap-adt/adt-clients` is one class with 28 public methods,
+ * handed out by `AdtClient.getUtils()` as itself. A concrete return is the one a
+ * consumer cannot substitute, cannot compose with their own types, and cannot
+ * have checked at the factory — see decision 12 here and decision 10 there.
+ *
+ * **The grain comes from ADT's own resource space**, read out of the endpoints
+ * the implementation calls:
+ *
+ * | family | atom |
+ * |---|---|
+ * | `/repository/informationsystem/*` | {@link IAdtInformationSystem} |
+ * | `/repository/nodestructure`, `/repository/objectstructure` | {@link IAdtRepositoryStructure} |
+ * | `/activation`, `/deletion` | {@link IAdtGroupLifecycle} |
+ * | `/datapreview/*` | {@link IAdtDataPreview} |
+ * | `/discovery` | {@link IAdtDiscovery} |
+ * | the per-type resources — `oo`, `programs`, `ddic`, `functions`, `enhancements` | {@link IAdtObjectAccess} |
+ *
+ * Deliberately *not* the grain a measurement suggested. When this split was
+ * chosen, the one legacy implementation refused exactly `getSqlQuery`,
+ * `getTableContents` and `getTransaction` — which would have given three atoms
+ * and a bag of 28. Those refusals fall **inside** these families rather than
+ * defining them, so architecture and observation agree; observation is simply
+ * narrower, and a contract split by who refuses what is a contract that changes
+ * shape with the next system.
+ *
+ * Removing `getTransaction` made that concrete rather than theoretical. The
+ * legacy implementation now refuses two members, and **both are
+ * {@link IAdtDataPreview}** — a whole family, refused whole, which is what a
+ * split along ADT's resources predicts and a split along refusals could not have
+ * known in advance. Had the atoms been drawn from the observation, one of the
+ * three would have evaporated when its member did.
+ *
+ * A few members compute a string and issue no request — `supportsSourceCode`,
+ * `getObjectSourceUri`, `modifyWhereUsedScope`. They stay with the family whose
+ * requests they prepare, because a consumer replacing that family needs them to
+ * build the same call.
+ *
+ * ## The gap, named rather than papered over
+ *
+ * **Every member states its result.** Twelve of the twenty-five answered
+ * `IAdtWireResponse` — the transport envelope, which every method could name and
+ * which told a consumer only that a request happened. They now answer the
+ * document their endpoint produced, and parsing it is the consumer's (decision
+ * 5). The other thirteen already stated what the caller gets.
+ *
+ * Counted as **members**, not signatures: `search` has two, because one endpoint
+ * is one member (decision 16) and the second signature is the strategy, not a
+ * second capability. A parser that counts signatures reports 26 and is not
+ * wrong about anything except the word.
+ *
+ *
+ * Six were removed because nobody calls them — `getTypeInfo`, `getTransaction`,
+ * `getBdef`, `getEnhancements`, `getEnhancementSpot`, `getEnhancementImpl`. Every
+ * mention of them across the sibling repositories was their own doc comment.
+ * The question was never which result they promise, but why they were in a
+ * contract; three of them were a second door to a handler that was already
+ * there — `getBdef` to `getBehaviorDefinition().read()`, `getEnhancementImpl`
+ * and `getEnhancementSpot` to `getEnhancement()` — and the other three named
+ * resources nothing else reaches. Deleted in `@mcp-abap-adt/adt-clients` with
+ * those three endpoints recorded, so a typed handler can be built where one is
+ * wanted rather than a generic member kept in case one is.
+ *
+ * Two were closed from evidence rather than measurement: `getAllTypes` answers
+ * the named-item list a trace catalogue answers with, and
+ * `fetchNodeStructure` answers objects plus the typed child nodes to walk next.
+ * Both shapes were lifted from parsers that have been reading those documents in
+ * `mcp-abap-adt` against real systems — code that works is evidence; a shape
+ * nobody has read is not.
+ *
+ * Evidence is not the same as being finished. `fetchNodeStructure` first shipped
+ * carrying the ids alone, which cannot say *which* node holds a given type, and
+ * 27.0.0 is that correction — found by a consumer trying to walk with it.
+ *
+ * The twelve are left as they are, deliberately. Closing them means naming what
+ * each endpoint sends, and 12 shapes would have to be named,
+ * and nothing but a capture can name them, which decision 1 forbids. **A strategy does not close them
+ * either** — handing the caller a parser makes the caller decide what comes
+ * back, and the point of a contract is that the consumer is not rewritten when
+ * the implementation changes. Strategy and result contract are different planes;
+ * an attempt to use one for the other cost every implementer two signatures per
+ * method before it was reverted.
+ *
+ * So they close one at a time, on captures. Until then this file states what a
+ * consumer gets for 13 members and admits the gap for 12, which is the honest
+ * shape of the thing rather than a finished one.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/auth/AuthType.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Authentication type
+ */
+export type AuthType = 'jwt' | 'xsuaa' | 'basic';
+//# sourceMappingURL=AuthType.d.ts.map

package/dist/auth/AuthType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthType.d.ts","sourceRoot":"","sources":["../../src/auth/AuthType.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC"}

package/dist/auth/AuthType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/auth/IAuthorizationConfig.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Authorization configuration - values needed for obtaining and refreshing tokens
+ * Returned by stores with actual values (not file paths)
+ */
+export interface IAuthorizationConfig {
+    /** UAA URL for token refresh */
+    uaaUrl: string;
+    /** UAA client ID */
+    uaaClientId: string;
+    /** UAA client secret */
+    uaaClientSecret: string;
+    /** Refresh token for token renewal (optional) */
+    refreshToken?: string;
+}
+//# sourceMappingURL=IAuthorizationConfig.d.ts.map

package/dist/auth/IAuthorizationConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAuthorizationConfig.d.ts","sourceRoot":"","sources":["../../src/auth/IAuthorizationConfig.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,wBAAwB;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/auth/IAuthorizationConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/auth/IAuthorizationStrategy.d.ts

@@ -0,0 +1,59 @@
+/**
+ * How an interactive authorization is conducted.
+ *
+ * The provider owns what it can compute — the authorization URL and the token
+ * exchange. Everything between them (reaching the URL, receiving what comes
+ * back, the port, the timeout) belongs to whoever implements this interface,
+ * which is why a consumer can replace it wholesale.
+ *
+ * See `ICallbackServer` for the transport a shipped strategy is composed of.
+ */
+import type { ILogger } from '@mcp-abap-adt/interfaces-utils';
+/** What the provider tells a strategy about the login to conduct. */
+export interface AuthorizationRequest {
+    /**
+     * Build the authorization URL for a redirect URI the strategy has settled on.
+     *
+     * Called once the strategy knows its redirect URI — which is what makes an
+     * ephemeral port possible, since the URL cannot be assembled before the
+     * socket is bound. May not be called at all: a strategy that already holds a
+     * payload needs no URL.
+     *
+     * Asynchronous because building may require OIDC discovery. Rejects when the
+     * redirect URI cannot be honoured — a pre-built authorization URL carries its
+     * own redirect, and a mismatch must fail here, before a browser is opened,
+     * rather than as a callback that never arrives.
+     */
+    buildAuthorizationUrl(redirectUri: string): Promise<string>;
+    /** For progress messages. Absent means silence — never stdout. */
+    readonly logger?: ILogger;
+}
+/** How the login ended. */
+export interface AuthorizationOutcome<TResult> {
+    /** What the redirect carried: a code, `{code, state}`, a SAMLResponse. */
+    readonly payload: TResult;
+    /**
+     * The redirect URI that actually took part. The token exchange must send this
+     * one — with an ephemeral port the provider has no other way to learn it.
+     */
+    readonly redirectUri: string;
+}
+/**
+ * A way of conducting an interactive authorization.
+ *
+ * `authorize` may be called again sequentially; an implementation that holds a
+ * fixed port should reject overlapping calls rather than queue them.
+ *
+ * `dispose` carries four obligations:
+ * - idempotent — every call after the first resolves as a no-op;
+ * - legal during an active `authorize`, which it ends with a rejection, since
+ *   releasing resources while a socket is still bound would be untrue;
+ * - resolves only once the resources are actually free;
+ * - never masks a failure from `authorize` — a caller invoking it from
+ *   `finally` propagates the original error and logs the cleanup one.
+ */
+export interface IAuthorizationStrategy<TResult> {
+    authorize(request: AuthorizationRequest): Promise<AuthorizationOutcome<TResult>>;
+    dispose?(): Promise<void>;
+}
+//# sourceMappingURL=IAuthorizationStrategy.d.ts.map

package/dist/auth/IAuthorizationStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAuthorizationStrategy.d.ts","sourceRoot":"","sources":["../../src/auth/IAuthorizationStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAE9D,qEAAqE;AACrE,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE5D,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,2BAA2B;AAC3B,MAAM,WAAW,oBAAoB,CAAC,OAAO;IAC3C,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sBAAsB,CAAC,OAAO;IAC7C,SAAS,CACP,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1C,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/dist/auth/IAuthorizationStrategy.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * How an interactive authorization is conducted.
+ *
+ * The provider owns what it can compute — the authorization URL and the token
+ * exchange. Everything between them (reaching the URL, receiving what comes
+ * back, the port, the timeout) belongs to whoever implements this interface,
+ * which is why a consumer can replace it wholesale.
+ *
+ * See `ICallbackServer` for the transport a shipped strategy is composed of.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });