@abapify/adt-client 0.4.0 → 0.4.3

package/README.md

@@ -89,6 +89,8 @@ createAdtClient(config: AdtConnectionConfig): AdtClient
 - `password` - SAP password
 - `client` - SAP client (optional, e.g., `'100'`)
 - `language` - SAP language (optional, e.g., `'EN'`)
+- `headersTimeoutMs` - response-header timeout for long-running SAP requests
+  (optional; otherwise the native HTTP client default applies)
 
 ### Class Operations
 

package/dist/index.d.mts

@@ -0,0 +1,578 @@
+import { exception } from "@abapify/adt-schemas";
+import { AdtClientType, AdtContract, ClassResponse, CrudContract, CrudContractBase, CrudQueryParams, DataElementResponse, DomainResponse, FunctionGroupResponse, FunctionModuleResponse, HttpAdapter, HttpAdapter as HttpAdapter$1, IncludeResponse, IncludesContractSkeleton, InterfaceResponse, LockOptions, ObjectStructureOptions, Package as PackageResponse, ProgramResponse, RestContract, RestEndpointDescriptor, Serializable, SourceOperations, SourcesContract, StructureResponse, TableResponse, TableTypeResponse, TransportResponse as TransportGetResponse, UnlockOptions, adtContract } from "@abapify/adt-contracts";
+import { Logger, Logger as Logger$1 } from "@abapify/logger";
+//#region src/errors.d.ts
+/**
+ * Parsed ADT exception structure - derived from ExceptionSchema
+ */
+interface AdtExceptionData {
+  /** Exception namespace ID (e.g., "com.sap.adt.oo") */
+  namespace?: string;
+  /** Exception type ID (e.g., "OBJECT_NOT_FOUND") */
+  type?: string;
+  /** Human-readable error message */
+  message?: string;
+  /** Localized error message */
+  localizedMessage?: string;
+  /** Additional properties as key-value pairs */
+  properties?: Record<string, string>;
+}
+/**
+ * Custom error class for ADT exceptions
+ *
+ * Provides structured access to SAP ADT error details.
+ */
+declare class AdtError extends Error {
+  /** HTTP status code */
+  readonly status: number;
+  /** HTTP status text */
+  readonly statusText: string;
+  /** Parsed ADT exception data (if available) */
+  readonly exception?: AdtExceptionData;
+  /** Raw response body */
+  readonly rawBody: string;
+  /** Request URL */
+  readonly url: string;
+  /** HTTP method */
+  readonly method: string;
+  constructor(options: {
+    status: number;
+    statusText: string;
+    url: string;
+    method: string;
+    rawBody: string;
+    exception?: AdtExceptionData;
+  });
+  /**
+   * Get the most relevant error message
+   */
+  get detailMessage(): string;
+  /**
+   * Check if this is a specific error type
+   */
+  isType(type: string): boolean;
+  /**
+   * Check if this is from a specific namespace
+   */
+  isNamespace(namespace: string): boolean;
+  /**
+   * Get a property value from the exception
+   */
+  getProperty(key: string): string | undefined;
+}
+//#endregion
+//#region src/types.d.ts
+interface AdtConnectionConfig {
+  baseUrl: string;
+  username?: string;
+  password?: string;
+  cookieHeader?: string;
+  authorizationHeader?: string;
+  client?: string;
+  language?: string;
+  logger?: Logger$1;
+  /** Override Undici's response-header timeout for long-running SAP requests. */
+  headersTimeoutMs?: number;
+}
+interface LockHandle {
+  lockHandle: string;
+  objectUri: string;
+}
+interface OperationResult {
+  success: boolean;
+  message?: string;
+}
+//#endregion
+//#region src/plugins/types.d.ts
+/**
+ * Plugin Types - Core interfaces for the response plugin system
+ */
+/**
+ * Response context passed to plugins
+ */
+interface ResponseContext {
+  /** Raw response text (XML) */
+  rawText: string;
+  /** Parsed response object (if schema available) */
+  parsedData?: unknown;
+  /** Request URL */
+  url: string;
+  /** Request method */
+  method: string;
+  /** Response content type */
+  contentType: string;
+}
+/**
+ * Response plugin interface
+ */
+interface ResponsePlugin {
+  /**
+   * Plugin name for identification
+   */
+  name: string;
+  /**
+   * Process response before returning to caller
+   * Can store files, transform data, log, etc.
+   *
+   * @param context - Response context with raw and parsed data
+   * @returns Modified data or original data
+   */
+  process(context: ResponseContext): Promise<unknown> | unknown;
+}
+//#endregion
+//#region src/adapter.d.ts
+/**
+ * Extended ADT connection config with plugins
+ */
+interface AdtAdapterConfig extends AdtConnectionConfig {
+  /** Response plugins for intercepting and transforming responses */
+  plugins?: ResponsePlugin[];
+  /**
+   * Callback when session expires (SAML redirect detected)
+   * Return new cookie header to retry the request, or throw to abort
+   */
+  onSessionExpired?: () => Promise<string>;
+}
+/** Options for an authenticated GET that returns plain text. */
+interface BoundedTextRequestOptions {
+  url: string;
+  headers?: Record<string, string>;
+}
+/**
+ * A response exceeded an explicit byte cap before its body was retained.
+ * Deliberately carries size metadata only, never response text.
+ */
+declare class AdtResponseTooLargeError extends Error {
+  readonly maxBytes: number;
+  readonly receivedBytes?: number | undefined;
+  readonly code: "ADT_RESPONSE_TOO_LARGE";
+  constructor(maxBytes: number, receivedBytes?: number | undefined);
+}
+/**
+ * Create ADT HTTP adapter with Basic or SAML Authentication and plugin support
+ */
+/** Extended adapter with ETag management */
+interface AdtHttpAdapter extends HttpAdapter$1 {
+  /** Clear cached ETag for a specific URL, or all ETags if no URL given */
+  clearETag(url?: string): void;
+  /** Read an authenticated plain-text response without exceeding maxBytes. */
+  readTextBounded(options: BoundedTextRequestOptions, maxBytes: number): Promise<string>;
+}
+declare function createAdtAdapter(config: AdtAdapterConfig): AdtHttpAdapter;
+//#endregion
+//#region src/services/transports.d.ts
+/**
+ * Transport data structure (simplified for service consumers)
+ */
+interface Transport {
+  number: string;
+  desc?: string;
+  owner?: string;
+  status?: string;
+  type?: string;
+  target?: string;
+  parent?: string;
+  lastChangedTimestamp?: string;
+  tasks?: TransportTask[];
+}
+interface TransportTask {
+  number: string;
+  desc?: string;
+  owner?: string;
+  status?: string;
+  type?: string;
+  parent?: string;
+  lastChangedTimestamp?: string;
+}
+/**
+ * Options for creating a transport
+ */
+interface CreateTransportOptions {
+  description: string;
+  type?: 'K' | 'W';
+  target?: string;
+  project?: string;
+  owner?: string;
+}
+/**
+ * Options for listing transports
+ */
+interface ListTransportsOptions {
+  targets?: string;
+  configUri?: string;
+}
+/**
+ * Transport Service - orchestrates CTS operations
+ */
+declare class TransportService {
+  private readonly adt;
+  constructor(adt: AdtClientType);
+  /**
+   * List transport requests
+   */
+  list(options?: ListTransportsOptions): Promise<Transport[]>;
+  /**
+   * Get a single transport by number
+   */
+  get(trkorr: string): Promise<Transport>;
+  /**
+   * Create a new transport request
+   *
+   * Note: Full create implementation requires XML body building.
+   * For now, this is a placeholder that throws a helpful error.
+   * Use ADK's AdkTransportRequest.create() for full functionality.
+   */
+  create(_options: CreateTransportOptions): Promise<Transport>;
+  /**
+   * Delete a transport request
+   */
+  delete(trkorr: string): Promise<void>;
+  /**
+   * Release a transport request
+   *
+   * Note: Release requires POST with specific action parameter.
+   * This is a placeholder for the full implementation.
+   */
+  release(_trkorr: string): Promise<void>;
+  /**
+   * Find a request/task unit whose number matches the wanted transport id.
+   * Handles both single-object and array shapes from ts-xsd.
+   */
+  private findUnit;
+  /**
+   * Extract requests array from various response formats
+   */
+  private extractRequests;
+  /**
+   * Map raw request data to Transport interface
+   */
+  private mapToTransport;
+  /**
+   * Extract tasks from transport data
+   */
+  private extractTasks;
+}
+/**
+ * Create transport service instance
+ */
+declare function createTransportService(adt: AdtClientType): TransportService;
+//#endregion
+//#region src/services/users.d.ts
+/** Normalized user info from Atom feed entries */
+interface UserInfo {
+  username: string;
+  fullName?: string;
+  uri?: string;
+}
+/** Current authenticated user info from systeminformation */
+interface CurrentUserInfo {
+  userName: string;
+  userFullName?: string;
+  systemID: string;
+  client: string;
+}
+/**
+ * User Service - orchestrates user lookup operations
+ */
+declare class UserService {
+  private readonly adt;
+  constructor(adt: AdtClientType);
+  /** Get the currently authenticated user via systeminformation */
+  getCurrentUser(): Promise<CurrentUserInfo>;
+  /** Look up a specific user by exact username */
+  getUserByName(username: string): Promise<UserInfo[]>;
+  /** Search users by wildcard query */
+  searchUsers(query: string, maxcount?: number): Promise<UserInfo[]>;
+}
+declare function createUserService(adt: AdtClientType): UserService;
+//#endregion
+//#region src/services/source-history.d.ts
+type SourceHistoryProtocolErrorCode = 'SOURCE_HISTORY_URI_UNSAFE' | 'SOURCE_VERSION_FEED_INVALID' | 'SOURCE_VERSION_ID_MISSING' | 'SOURCE_VERSION_CONTENT_LINK_MISSING';
+declare class SourceHistoryProtocolError extends Error {
+  readonly code: SourceHistoryProtocolErrorCode;
+  readonly ordinal?: number | undefined;
+  constructor(code: SourceHistoryProtocolErrorCode, message: string, ordinal?: number | undefined);
+}
+interface SourceVersionRef {
+  id: string;
+  ordinal: number;
+  title?: string;
+  sourceUri: string;
+  contentType?: string;
+  etag?: string;
+  updatedAt?: string;
+  author?: string;
+  transports: string[];
+}
+type SourceVersionReference = SourceVersionRef;
+type BoundedSourceReader = (sourceUri: string, maxBytes: number) => Promise<string>;
+/**
+ * An immutable source body crossed its configured byte limit.
+ * This error intentionally does not retain the source URI or any source text.
+ */
+declare class SourceVersionTooLargeError extends Error {
+  readonly maxBytes: number;
+  readonly receivedBytes?: number | undefined;
+  readonly code: "SOURCE_VERSION_TOO_LARGE";
+  constructor(maxBytes: number, receivedBytes?: number | undefined);
+}
+declare function assertAdtUri(uri: string): string;
+declare function normalizeSourceVersionFeed(payload: unknown, versionsUri: string): SourceVersionRef[];
+declare class SourceHistoryService {
+  private readonly adt;
+  private readonly boundedSourceReader?;
+  constructor(adt: AdtClientType, boundedSourceReader?: BoundedSourceReader | undefined);
+  listVersions(versionsUri: string): Promise<SourceVersionRef[]>;
+  readVersionSource(sourceUri: string): Promise<string>;
+  readVersionSourceBounded(sourceUri: string, maxBytes: number): Promise<string>;
+}
+declare function createSourceHistoryService(adt: AdtClientType, boundedSourceReader?: BoundedSourceReader): SourceHistoryService;
+//#endregion
+//#region src/client.d.ts
+/**
+ * Fetch options for generic HTTP requests
+ */
+interface FetchOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  headers?: Record<string, string>;
+  body?: string;
+}
+/** Options for a bounded authenticated GET that returns plain text. */
+interface BoundedTextFetchOptions {
+  headers?: Record<string, string>;
+}
+/**
+ * Services layer - business logic orchestration
+ */
+interface AdtServices {
+  transports: TransportService;
+  sourceHistory: SourceHistoryService;
+}
+interface AdtClientReturn {
+  adt: AdtClientType;
+  services: AdtServices;
+  fetch: (url: string, options?: FetchOptions) => Promise<unknown>;
+  readTextBounded: (url: string, maxBytes: number, options?: BoundedTextFetchOptions) => Promise<string>;
+  /** Clear cached ETag for a specific URL, or all ETags if no URL given */
+  clearETag: (url?: string) => void;
+}
+declare function createAdtClient(config: AdtAdapterConfig): AdtClientReturn;
+type AdtClient = ReturnType<typeof createAdtClient>;
+//#endregion
+//#region src/cancellation.d.ts
+/**
+ * Runs an ADT operation with an execution-scoped abort signal. Async local
+ * storage keeps concurrent clients and invocations isolated without mutating
+ * shared client state.
+ */
+declare function runWithAdtAbortSignal<T>(signal: AbortSignal, operation: () => Promise<T>): Promise<T>;
+//#endregion
+//#region src/plugins/logging.d.ts
+type LogFunction = (message: string, data?: any) => void;
+/**
+ * Logging plugin - logs requests and responses
+ */
+declare class LoggingPlugin implements ResponsePlugin {
+  private readonly logger;
+  name: string;
+  constructor(logger?: LogFunction);
+  process(context: ResponseContext): unknown;
+}
+//#endregion
+//#region src/plugins/file-logging.d.ts
+interface FileLoggingConfig {
+  outputDir: string;
+  writeMetadata?: boolean;
+  logger?: Logger$1;
+}
+/**
+ * Plugin that logs HTTP responses to files
+ * Similar to v1's FileLogger functionality
+ */
+declare class FileLoggingPlugin implements ResponsePlugin {
+  private readonly config;
+  name: string;
+  constructor(config: FileLoggingConfig);
+  process(context: ResponseContext): unknown;
+  /**
+   * Generate file path for HTTP response
+   * Converts URL to fixture-style path structure
+   */
+  private generateFilePath;
+  /**
+   * Get metadata file path for a response file
+   */
+  private getMetadataPath;
+}
+//#endregion
+//#region src/utils/session.d.ts
+/**
+ * Fetch function injected into SessionManager so the adapter can route
+ * CSRF handshake requests through the same Undici dispatcher (and
+ * headersTimeout) used for the final adapter request. Defaults to the
+ * global fetch when no dispatcher is configured.
+ */
+type SessionFetchFn = (input: string | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Cookie Store - Manages HTTP cookies for stateful sessions
+ */
+declare class CookieStore {
+  private readonly cookies;
+  /**
+   * Parse Set-Cookie header and store cookies
+   * Handles complex cookie strings with expires dates
+   */
+  parseCookies(setCookieHeader: string): void;
+  /**
+   * Split Set-Cookie header by commas, avoiding splitting on expires dates
+   */
+  private splitCookieHeader;
+  /**
+   * Get Cookie header value for requests
+   */
+  getCookieHeader(): string | undefined;
+  /**
+   * Check if we have any cookies
+   */
+  hasCookies(): boolean;
+  /**
+   * Clear all cookies
+   */
+  clear(): void;
+  /**
+   * Get all cookies as a map (for testing/debugging)
+   */
+  getAll(): Map<string, string>;
+  /**
+   * Inject pre-existing cookies (e.g., from SAML authentication)
+   * @param cookieString Cookie string in "name=value; name2=value2" format
+   */
+  injectCookie(cookieString: string): void;
+}
+/**
+ * CSRF Token Manager - Handles CSRF token caching and initialization
+ */
+declare class CsrfTokenManager {
+  private cachedToken?;
+  /**
+   * Extract CSRF token from cookies (SAP stores it there)
+   */
+  extractFromCookies(cookies: Map<string, string>): string | undefined;
+  /**
+   * Extract CSRF token from response header
+   */
+  extractFromHeader(headerValue: string | null): string | undefined;
+  /**
+   * Cache a CSRF token
+   */
+  cache(token: string): void;
+  /**
+   * Get cached CSRF token
+   */
+  getCached(): string | undefined;
+  /**
+   * Clear cached CSRF token (e.g., on 403 errors)
+   */
+  clear(): void;
+  /**
+   * Check if we have a cached token
+   */
+  hasCached(): boolean;
+  /**
+   * Alias for hasCached() - for consistency with SessionManager API
+   */
+  hasToken(): boolean;
+}
+/**
+ * Session Manager - Orchestrates cookies and CSRF tokens
+ */
+declare class SessionManager {
+  private readonly logger?;
+  private readonly fetchFn;
+  private static readonly SESSION_PATH_PREFIX;
+  private readonly cookieStore;
+  private readonly csrfManager;
+  private readonly etagManager;
+  private securitySessionActive;
+  constructor(logger?: Logger$1 | undefined, fetchFn?: SessionFetchFn);
+  /**
+   * Process response to update session state
+   * Extracts cookies, CSRF tokens, and ETags
+   * @param response The HTTP response
+   * @param url Optional URL for ETag caching (required for ETag tracking)
+   */
+  processResponse(response: Response, url?: string): void;
+  /**
+   * Get headers for next request
+   * @param method HTTP method
+   * @param url Optional URL for ETag lookup (for PUT/PATCH with optimistic locking)
+   */
+  getRequestHeaders(method: string, url?: string): Record<string, string>;
+  /**
+   * Get cached ETag for a URL
+   */
+  getETag(url: string): string | undefined;
+  /**
+   * Clear cached ETag for a URL
+   */
+  clearETag(url?: string): void;
+  /**
+   * Reject session paths that could send cleanup requests off-target.
+   * Only relative paths under the ADT sessions endpoint (or same-origin
+   * absolute URLs with that path) are accepted.
+   */
+  private isTrustedSessionPath;
+  private extractTrustedSessionPath;
+  /**
+   * Initialize CSRF token using the Eclipse ADT security session flow:
+   *
+   * 1. GET /sessions + x-sap-security-session: create  → create security session
+   * 2. GET /sessions + x-sap-security-session: use + x-csrf-token: Fetch → get CSRF token
+   * 3. DELETE /sessions/<id> + x-sap-security-session: use + x-csrf-token → destroy session
+   *
+   * The CSRF token survives the session deletion and remains valid for
+   * all subsequent lock/unlock operations. Deleting the session frees
+   * the slot — SAP allows only one security session per user.
+   */
+  private resolveInitializeCsrfArgs;
+  initializeCsrf(baseUrl: string, authHeader?: string, client?: string, language?: string, signal?: AbortSignal): Promise<boolean>;
+  initializeCsrf(baseUrl: string, options?: {
+    authHeader?: string;
+    client?: string;
+    language?: string;
+    signal?: AbortSignal;
+  }): Promise<boolean>;
+  private buildSessionsUrl;
+  private buildSessionHeaders;
+  private createSecuritySession;
+  private acquireCsrfToken;
+  private deleteSecuritySession;
+  private fetchSecuritySessionCsrfToken;
+  private deleteSecuritySessionWithFallback;
+  private handleCsrfInitializationError;
+  /**
+   * Clear all session state (cookies and CSRF)
+   */
+  clear(): void;
+  /**
+   * Check if we have a cached CSRF token
+   */
+  hasCsrfToken(): boolean;
+  /**
+   * Get Cookie header value for requests
+   */
+  getCookieHeader(): string | undefined;
+  /**
+   * Get session type header value
+   * SAP ADT requires 'stateful' for operations that need session persistence
+   */
+  getSessionTypeHeader(): string;
+  /**
+   * Inject a pre-existing cookie (e.g., from SAML authentication)
+   * @param cookieString Cookie string in "name=value" format
+   */
+  injectCookie(cookieString: string): void;
+}
+//#endregion
+export { type AdtAdapterConfig, type AdtClient, type AdtConnectionConfig, type AdtContract, type AdtError, type AdtHttpAdapter, AdtResponseTooLargeError, type BoundedSourceReader, type BoundedTextFetchOptions, type BoundedTextRequestOptions, type ClassResponse, CookieStore, type CreateTransportOptions, type CrudContract, type CrudContractBase, type CrudQueryParams, CsrfTokenManager, type CurrentUserInfo, type DataElementResponse, type DomainResponse, type FileLoggingConfig, FileLoggingPlugin, type FunctionGroupResponse, type FunctionModuleResponse, type HttpAdapter, type IncludeResponse, type IncludesContractSkeleton, type InterfaceResponse, type ListTransportsOptions, type LockHandle, type LockOptions, type LogFunction, type Logger, LoggingPlugin, type ObjectStructureOptions, type OperationResult, type PackageResponse, type ProgramResponse, type ResponseContext, type ResponsePlugin, type RestContract, type RestEndpointDescriptor, type Serializable, SessionManager, SourceHistoryProtocolError, type SourceHistoryProtocolErrorCode, SourceHistoryService, type SourceOperations, type SourceVersionRef, type SourceVersionReference, SourceVersionTooLargeError, type SourcesContract, type StructureResponse, type TableResponse, type TableTypeResponse, type Transport, type TransportGetResponse, TransportService, type TransportTask, type UnlockOptions, type UserInfo, UserService, adtContract, assertAdtUri, createAdtAdapter, createAdtClient, createSourceHistoryService, createTransportService, createUserService, normalizeSourceVersionFeed, runWithAdtAbortSignal };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/plugins/types.ts","../src/adapter.ts","../src/services/transports.ts","../src/services/users.ts","../src/services/source-history.ts","../src/client.ts","../src/cancellation.ts","../src/plugins/logging.ts","../src/plugins/file-logging.ts","../src/utils/session.ts"],"mappings":"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"}