@sap-ux/backend-proxy-middleware-cf 0.0.99 → 0.1.1

package/dist/proxy/utils.d.ts

@@ -0,0 +1,65 @@
+import type { IncomingMessage } from 'node:http';
+import type { MimeInfo, RouteEntry } from '../types';
+/**
+ * Escape a string so it can be safely embedded in a RegExp.
+ *
+ * @param value - Raw string.
+ * @returns Regex-safe string with all metacharacters escaped.
+ */
+export declare function escapeRegExp(value: string): string;
+/**
+ * Replaces oldUrl with newUrl in text (regex-safe).
+ *
+ * @param text - Full text to replace in.
+ * @param oldUrl - URL to replace (will be escaped for regex).
+ * @param newUrl - Replacement URL.
+ * @returns Text with URLs replaced.
+ */
+export declare function replaceUrl(text: string, oldUrl: string, newUrl: string): string;
+/**
+ * Returns a path filter that accepts pathnames matching any custom route pattern or any destination route regex.
+ *
+ * @param customRoutes - Route path patterns (e.g. '/', '/login/callback').
+ * @param routes - Route entries with compiled regex.
+ * @returns Filter function (pathname) => boolean.
+ */
+export declare function createPathFilter(customRoutes: string[], routes: RouteEntry[]): (pathname: string) => boolean;
+/**
+ * Check if request originated from the approuter (server-to-server).
+ * Detects the custom marker header that was set when the proxy originally
+ * forwarded this request to the approuter. The approuter preserves it
+ * when proxying back to the ui5-server destination.
+ *
+ * @param req - Incoming request.
+ * @returns True if request came from approuter.
+ */
+export declare function isRequestFromApprouter(req: IncomingMessage): boolean;
+/**
+ * Creates a proxy filter that checks both route matching and approuter origin.
+ * Skips proxying when the request comes from the approuter to prevent infinite loops.
+ *
+ * @param customRoutes - Route path patterns (e.g. '/', '/login/callback').
+ * @param routes - Route entries with compiled regex.
+ * @returns Filter function (pathname, req) => boolean for http-proxy-middleware.
+ */
+export declare function createProxyFilter(customRoutes: string[], routes: RouteEntry[]): (pathname: string, req: IncomingMessage) => boolean;
+/**
+ * Build origin URL from request headers (x-forwarded-proto, x-forwarded-host) and baseUrl.
+ *
+ * @param req - Request-like object.
+ * @param req.headers - Request headers.
+ * @param req.baseUrl - Optional base URL path.
+ * @returns Origin URL string.
+ */
+export declare function getRequestOrigin(req: IncomingMessage & {
+    baseUrl?: string;
+}): string;
+/**
+ * Get mime type, charset and content-type header value from pathname and optional Content-Type header.
+ *
+ * @param pathname - Request path (used when no ctValue).
+ * @param ctValue - Content-Type header value.
+ * @returns MimeInfo object.
+ */
+export declare function getMimeInfo(pathname: string, ctValue: string | undefined): MimeInfo;
+//# sourceMappingURL=utils.d.ts.map

package/dist/proxy/utils.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegExp = escapeRegExp;
+exports.replaceUrl = replaceUrl;
+exports.createPathFilter = createPathFilter;
+exports.isRequestFromApprouter = isRequestFromApprouter;
+exports.createProxyFilter = createProxyFilter;
+exports.getRequestOrigin = getRequestOrigin;
+exports.getMimeInfo = getMimeInfo;
+const mime_types_1 = __importDefault(require("mime-types"));
+const content_type_1 = __importDefault(require("content-type"));
+const constants_1 = require("../config/constants");
+/**
+ * Escape a string so it can be safely embedded in a RegExp.
+ *
+ * @param value - Raw string.
+ * @returns Regex-safe string with all metacharacters escaped.
+ */
+function escapeRegExp(value) {
+    return value.replaceAll(/[-/\\^$*+?.()|[\]{}]/g, String.raw `\$&`);
+}
+/**
+ * Replaces oldUrl with newUrl in text (regex-safe).
+ *
+ * @param text - Full text to replace in.
+ * @param oldUrl - URL to replace (will be escaped for regex).
+ * @param newUrl - Replacement URL.
+ * @returns Text with URLs replaced.
+ */
+function replaceUrl(text, oldUrl, newUrl) {
+    const regex = new RegExp(escapeRegExp(oldUrl), 'gi');
+    return text.replace(regex, newUrl);
+}
+/**
+ * Returns a path filter that accepts pathnames matching any custom route pattern or any destination route regex.
+ *
+ * @param customRoutes - Route path patterns (e.g. '/', '/login/callback').
+ * @param routes - Route entries with compiled regex.
+ * @returns Filter function (pathname) => boolean.
+ */
+function createPathFilter(customRoutes, routes) {
+    const compiledCustomRoutes = customRoutes.map((route) => new RegExp(String.raw `^${escapeRegExp(route)}(\?.*)?$`));
+    return (pathname) => {
+        return (compiledCustomRoutes.some((customRoute) => customRoute.test(pathname)) ||
+            routes.some((route) => route.sourcePattern.test(pathname)));
+    };
+}
+/**
+ * Check if request originated from the approuter (server-to-server).
+ * Detects the custom marker header that was set when the proxy originally
+ * forwarded this request to the approuter. The approuter preserves it
+ * when proxying back to the ui5-server destination.
+ *
+ * @param req - Incoming request.
+ * @returns True if request came from approuter.
+ */
+function isRequestFromApprouter(req) {
+    return !!req.headers[constants_1.PROXY_MARKER_HEADER];
+}
+/**
+ * Creates a proxy filter that checks both route matching and approuter origin.
+ * Skips proxying when the request comes from the approuter to prevent infinite loops.
+ *
+ * @param customRoutes - Route path patterns (e.g. '/', '/login/callback').
+ * @param routes - Route entries with compiled regex.
+ * @returns Filter function (pathname, req) => boolean for http-proxy-middleware.
+ */
+function createProxyFilter(customRoutes, routes) {
+    const pathFilter = createPathFilter(customRoutes, routes);
+    return (pathname, req) => {
+        return !isRequestFromApprouter(req) && pathFilter(pathname);
+    };
+}
+/**
+ * Build origin URL from request headers (x-forwarded-proto, x-forwarded-host) and baseUrl.
+ *
+ * @param req - Request-like object.
+ * @param req.headers - Request headers.
+ * @param req.baseUrl - Optional base URL path.
+ * @returns Origin URL string.
+ */
+function getRequestOrigin(req) {
+    return `${String((req.headers['x-forwarded-proto'] ?? 'https').toString().split(',')[0])}://${req.headers['x-forwarded-host'] ?? ''}${req.baseUrl ?? ''}`;
+}
+/**
+ * Get mime type, charset and content-type header value from pathname and optional Content-Type header.
+ *
+ * @param pathname - Request path (used when no ctValue).
+ * @param ctValue - Content-Type header value.
+ * @returns MimeInfo object.
+ */
+function getMimeInfo(pathname, ctValue) {
+    if (ctValue) {
+        const parsed = content_type_1.default.parse(ctValue);
+        const type = parsed.type ?? 'application/octet-stream';
+        const charset = parsed.parameters?.charset ?? mime_types_1.default.charset(type) ?? 'utf-8';
+        return {
+            type,
+            charset,
+            contentType: content_type_1.default.format({ type, parameters: parsed.parameters })
+        };
+    }
+    const type = mime_types_1.default.lookup(pathname) || 'application/octet-stream';
+    const charset = mime_types_1.default.charset(type) || 'utf-8';
+    return {
+        type,
+        charset,
+        contentType: `${type}; charset=${charset}`
+    };
+}
+//# sourceMappingURL=utils.js.map

package/dist/types.d.ts

@@ -1,55 +1,152 @@
+import type { ToolsLogger } from '@sap-ux/logger';
 /**
- * Configuration for a single backend destination.
+ * Destination configuration for approuter (name must match routes in xs-app.json).
  */
-export interface BackendDestination {
-    /**
-     * Destination URL to proxy requests to.
-     */
+export interface ApprouterDestination {
+    /** Destination name used in xs-app.json routes */
+    name: string;
+    /** URI of the host to proxy to */
     url: string;
-    /**
-     * Array of OData source paths to proxy to this destination.
-     * Each path represents an OData service that should be proxied to the destination URL.
-     * Requests matching these paths will have the path prefix removed before forwarding.
-     */
-    paths: string[];
-    /**
-     * Optional path rewriting. When specified, the matched path prefix will be replaced
-     * with this value before forwarding to the backend.
-     * If not specified, the matched path is simply removed.
-     */
-    pathRewrite?: string;
-}
-/**
- * Configuration for Cloud Foundry OAuth middleware.
- */
-export interface CfOAuthMiddlewareConfig {
-    /**
-     * Array of backend destinations.
-     * Each destination has its own URL and paths.
-     */
-    backends: BackendDestination[];
-    /**
-     * Manual OAuth credentials (optional).
-     * If not provided, middleware will attempt to auto-detect from Cloud Foundry ADP project.
-     */
-    credentials?: {
-        /**
-         * OAuth2 client ID.
-         */
-        clientId: string;
-        /**
-         * OAuth2 client secret.
-         */
-        clientSecret: string;
-        /**
-         * Base URL for the OAuth token endpoint.
-         * The token endpoint will be constructed as: {url}/oauth/token
-         */
-        url: string;
-    };
-    /**
-     * Enable debug logging.
-     */
+}
+/**
+ * Extension to be required and injected into the local approuter instance.
+ */
+export interface ApprouterExtension {
+    /** Local path (e.g. "./my-extension.js") or module path (e.g. "@scope/package/extension.js") */
+    module: string;
+    /** Optional parameters injected into the extension handler as 4th argument */
+    parameters?: Record<string, string>;
+}
+/**
+ * Configuration for the backend-proxy-middleware-cf (approuter-based).
+ * Options are merged with defaults; configuration can be partial.
+ */
+export interface BackendProxyMiddlewareCfConfig {
+    /** Verbose logging */
     debug?: boolean;
+    /** Port to run the underlying approuter on */
+    port?: number;
+    /** Path to xs-app.json (relative to project root). Defaults to './xs-app.json'. */
+    xsappJsonPath?: string;
+    /** Path to the environment options file (relative to project root) */
+    envOptionsPath?: string;
+    /** Destinations: array of { name, url } (e.g. from default-env.json). Destination names must match routes in xs-app.json. */
+    destinations?: ApprouterDestination[] | string;
+    /** Allow BTP services configured in xs-app.json (requires authenticated BTP session) */
+    allowServices?: boolean;
+    /** Authentication method for routes */
+    authenticationMethod?: 'none' | 'route';
+    /** Allow static assets to be served by approuter (default false; usually ui5-server serves them) */
+    allowLocalDir?: boolean;
+    /** Subdomain for multitenancy (optional) */
+    subdomain?: string | null;
+    /** Replace proxied URL in response body with server URL */
+    rewriteContent?: boolean;
+    /** Content types to rewrite when rewriteContent is true */
+    rewriteContentTypes?: string[];
+    /** Approuter extensions (module path + optional parameters) */
+    extensions?: ApprouterExtension[];
+    /** Add route for HTML pages to trigger XSUAA login when authenticationMethod !== 'none' */
+    appendAuthRoute?: boolean;
+    /** Disable welcome file handling from xs-app.json */
+    disableWelcomeFile?: boolean;
+    /** Disable automatic injection of ui5-server routes (resources, test-resources, catch-all) */
+    disableUi5ServerRoutes?: boolean;
+}
+/** Effective options with defaults applied. */
+export interface EffectiveOptions extends BackendProxyMiddlewareCfConfig {
+    port: number;
+    xsappJsonPath: string;
+    destinations: ApprouterDestination[];
+    rewriteContentTypes: string[];
+    extensions: ApprouterExtension[];
+}
+/** Route entry with compiled regex and resolved destination URL. */
+export interface RouteEntry {
+    sourcePattern: RegExp;
+    path: string;
+    url?: string;
+    source: string;
+    destination?: string;
+}
+/** Mime info for response handling. */
+export interface MimeInfo {
+    type: string;
+    charset: string;
+    contentType: string;
+}
+/** Single route entry in xs-app.json (minimal shape we use). */
+export interface XsappRoute {
+    source: string;
+    destination?: string;
+    endpoint?: string;
+    localDir?: string;
+    service?: string;
+    authenticationType?: string;
+    target?: string;
+    cacheControl?: string;
+}
+/** Parsed xs-app.json shape (minimal for our use). */
+export interface XsappConfig {
+    routes?: XsappRoute[];
+    welcomeFile?: string;
+    authenticationMethod?: string;
+    login?: {
+        callbackEndpoint?: string;
+    };
+    logout?: {
+        logoutEndpoint?: string;
+    };
+}
+/**
+ * Options for building RouteEntry[] from a prepared xsappConfig
+ */
+export interface BuildRouteEntriesOptions {
+    xsappConfig: XsappConfig;
+    effectiveOptions: EffectiveOptions;
+    logger: ToolsLogger;
+}
+/**
+ * Options for loading and preparing xs-app.json (no destinations needed)
+ */
+export interface PrepareXsappConfigOptions {
+    rootPath: string;
+    xsappJsonPath: string;
+    effectiveOptions: EffectiveOptions;
+    sourcePath: string;
+    logger: ToolsLogger;
+}
+/** Options for creating the proxy middleware. */
+export interface CreateProxyOptions {
+    /** Path patterns to proxy (e.g. '/', '/login/callback', logout endpoint). */
+    customRoutes: string[];
+    /** Route entries from xs-app (regex + destination URL). */
+    routes: RouteEntry[];
+    /** Target base URI (e.g. http://localhost:port). */
+    baseUri: string;
+    /** Merged options (debug, rewriteContent, etc.). */
+    effectiveOptions: EffectiveOptions;
+    /** External URL for BAS (from exposePort). Overrides x-forwarded-host/proto in proxy requests. */
+    basExternalUrl?: URL;
+}
+/**
+ * Approuter extension handler: Express-like (req, res, next) with optional 4th params from config
+ */
+export type ExtensionHandler = (req: unknown, res: unknown, next: unknown, params?: Record<string, string>) => void;
+/**
+ * Extension module shape expected from approuter extensions
+ */
+export interface ExtensionModule {
+    insertMiddleware?: Record<string, Array<ExtensionHandler | {
+        path?: string;
+        handler: ExtensionHandler;
+    }>>;
+}
+/**
+ * Loaded extension modules and list of extension routes (paths) they register.
+ */
+export interface LoadedExtensions {
+    modules: ExtensionModule[];
+    routes: string[];
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import type { ToolsLogger } from '@sap-ux/logger';
+/**
+ * Returns the next free port starting from basePort.
+ *
+ * @param basePort - Base port to start searching from.
+ * @param logger - Optional logger to warn if portfinder fails and basePort is used.
+ * @returns A free port number.
+ */
+export declare function nextFreePort(basePort: number, logger?: ToolsLogger): Promise<number>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextFreePort = nextFreePort;
+const portfinder_1 = __importDefault(require("portfinder"));
+/**
+ * Returns the next free port starting from basePort.
+ *
+ * @param basePort - Base port to start searching from.
+ * @param logger - Optional logger to warn if portfinder fails and basePort is used.
+ * @returns A free port number.
+ */
+async function nextFreePort(basePort, logger) {
+    try {
+        portfinder_1.default.basePort = basePort;
+        return await portfinder_1.default.getPortPromise();
+    }
+    catch {
+        logger?.warn(`portfinder failed, using base port ${basePort}.`);
+        return basePort;
+    }
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap-ux/backend-proxy-middleware-cf",
-  "description": "OAuth2 Bearer token middleware for Cloud Foundry adaptation projects",
+  "description": "UI5 server middleware using @sap/approuter for CF-style destinations and xs-app.json",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",
@@ -9,7 +9,7 @@
   "bugs": {
     "url": "https://github.com/SAP/open-ux-tools/issues?q=is%3Aopen+is%3Aissue+label%3Abug+label%3Abackend-proxy-middleware-cf"
   },
-  "version": "0.0.99",
+  "version": "0.1.1",
   "license": "Apache-2.0",
   "author": "@SAP/ux-tools-team",
   "main": "dist/index.js",
@@ -21,21 +21,21 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "axios": "1.13.6",
+    "@sap/approuter": "^20.8.0",
+    "content-type": "^1.0.5",
+    "dotenv": "^16.4.5",
     "http-proxy-middleware": "3.0.5",
-    "@sap-ux/adp-tooling": "0.18.109",
-    "@sap-ux/logger": "0.8.4",
-    "@sap-ux/project-access": "1.35.18"
+    "mime-types": "^2.1.35",
+    "portfinder": "^1.0.32",
+    "@sap-ux/adp-tooling": "0.18.111",
+    "@sap-ux/btp-utils": "1.1.12",
+    "@sap-ux/logger": "0.8.4"
   },
   "devDependencies": {
+    "@types/content-type": "^1.0.0",
     "@types/express": "4.17.21",
     "@types/http-proxy": "^1.17.5",
-    "@types/supertest": "7.2.0",
-    "express": "4.22.1",
-    "nock": "14.0.11",
-    "supertest": "7.2.2",
-    "connect": "^3.7.0",
-    "@types/connect": "^3.4.38"
+    "@types/mime-types": "^2.1.4"
   },
   "engines": {
     "node": ">=20.x"

package/ui5.yaml

@@ -1,4 +1,4 @@
-specVersion: '2.6'
+specVersion: '3.0'
 metadata:
     name: backend-proxy-middleware-cf
 kind: extension

package/dist/proxy.d.ts

@@ -1,42 +0,0 @@
-import type connect from 'connect';
-import { type Request, Router } from 'express';
-import type { Options } from 'http-proxy-middleware';
-import type { IncomingMessage } from 'node:http';
-import type { ToolsLogger } from '@sap-ux/logger';
-import type { OAuthTokenProvider } from './token';
-export type EnhancedIncomingMessage = (IncomingMessage & Pick<Request, 'originalUrl'>) | connect.IncomingMessage;
-/**
- * Creates proxy options for http-proxy-middleware.
- *
- * @param {string} targetUrl - The target URL to proxy to.
- * @param {string} matchedPath - The path prefix that was matched by the router.
- * @param {string | undefined} pathRewrite - Optional replacement path.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {Options} Proxy options configuration.
- */
-export declare function createProxyOptions(targetUrl: string, matchedPath: string, pathRewrite: string | undefined, logger: ToolsLogger): Options;
-/**
- * Registers a proxy route for a given path.
- *
- * @param {string} path - Path to register.
- * @param {string} destinationUrl - Target URL for proxying.
- * @param {string | undefined} pathRewrite - Optional rewrite path.
- * @param {OAuthTokenProvider} tokenProvider - Token provider instance.
- * @param {ToolsLogger} logger - Logger instance.
- * @param {Router} router - Express router instance.
- */
-export declare function registerProxyRoute(path: string, destinationUrl: string, pathRewrite: string | undefined, tokenProvider: OAuthTokenProvider, logger: ToolsLogger, router: Router): void;
-/**
- * Sets up all proxy routes for the configured backends.
- *
- * @param {Array<{url: string, paths: string[], pathRewrite?: string}>} backends - Array of backend configurations.
- * @param {OAuthTokenProvider} tokenProvider - Token provider instance.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {Router} Configured Express router.
- */
-export declare function setupProxyRoutes(backends: Array<{
-    url: string;
-    paths: string[];
-    pathRewrite?: string;
-}>, tokenProvider: OAuthTokenProvider, logger: ToolsLogger): Router;
-//# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProxyOptions = createProxyOptions;
-exports.registerProxyRoute = registerProxyRoute;
-exports.setupProxyRoutes = setupProxyRoutes;
-const express_1 = require("express");
-const http_proxy_middleware_1 = require("http-proxy-middleware");
-/**
- * Creates proxy options for http-proxy-middleware.
- *
- * @param {string} targetUrl - The target URL to proxy to.
- * @param {string} matchedPath - The path prefix that was matched by the router.
- * @param {string | undefined} pathRewrite - Optional replacement path.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {Options} Proxy options configuration.
- */
-function createProxyOptions(targetUrl, matchedPath, pathRewrite, logger) {
-    return {
-        target: targetUrl,
-        changeOrigin: true,
-        pathRewrite: (path, req) => {
-            // Express router.use() strips the matched path from req.url,
-            // use originalUrl to get the full path before Express stripped it
-            const originalUrl = req.originalUrl ?? req.url ?? path;
-            const urlPath = originalUrl.split('?')?.[0];
-            const queryString = originalUrl.includes('?') ? originalUrl.substring(originalUrl.indexOf('?')) : '';
-            // Strip the matched path prefix
-            let rewrittenPath = urlPath;
-            if (urlPath.startsWith(matchedPath)) {
-                rewrittenPath = urlPath.substring(matchedPath.length);
-            }
-            // Add the replacement prefix if specified
-            if (pathRewrite !== undefined) {
-                const sanitizedRewrite = pathRewrite.replace(/\/$/, ''); // Remove trailing slash
-                rewrittenPath = sanitizedRewrite + rewrittenPath;
-            }
-            const finalPath = rewrittenPath + queryString;
-            logger.debug(`Rewrite path ${originalUrl} > ${finalPath}`);
-            return finalPath;
-        },
-        on: {
-            error: (err, req, _res, _target) => {
-                logger.error(`Proxy error for ${req.originalUrl ?? req.url}: ${err.message}`);
-                if (typeof req.next === 'function') {
-                    req.next(err);
-                }
-            }
-        }
-    };
-}
-/**
- * Registers a proxy route for a given path.
- *
- * @param {string} path - Path to register.
- * @param {string} destinationUrl - Target URL for proxying.
- * @param {string | undefined} pathRewrite - Optional rewrite path.
- * @param {OAuthTokenProvider} tokenProvider - Token provider instance.
- * @param {ToolsLogger} logger - Logger instance.
- * @param {Router} router - Express router instance.
- */
-function registerProxyRoute(path, destinationUrl, pathRewrite, tokenProvider, logger, router) {
-    const proxyOptions = createProxyOptions(destinationUrl, path, pathRewrite, logger);
-    const proxyFn = (0, http_proxy_middleware_1.createProxyMiddleware)(proxyOptions);
-    const tokenMiddleware = tokenProvider.createTokenMiddleware();
-    router.use(path, tokenMiddleware, proxyFn);
-    const rewriteInfo = pathRewrite ? ` (rewrite to: ${pathRewrite})` : ' (strip prefix)';
-    logger.info(`Registered proxy for path: ${path} -> ${destinationUrl}${rewriteInfo}`);
-}
-/**
- * Sets up all proxy routes for the configured backends.
- *
- * @param {Array<{url: string, paths: string[], pathRewrite?: string}>} backends - Array of backend configurations.
- * @param {OAuthTokenProvider} tokenProvider - Token provider instance.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {Router} Configured Express router.
- */
-function setupProxyRoutes(backends, tokenProvider, logger) {
-    const router = (0, express_1.Router)();
-    for (const backend of backends) {
-        for (const path of backend.paths) {
-            try {
-                registerProxyRoute(path, backend.url, backend.pathRewrite, tokenProvider, logger, router);
-            }
-            catch (e) {
-                throw new Error(`Failed to register proxy for ${path}. Check configuration in yaml file. \n\t${e.message}`);
-            }
-        }
-    }
-    return router;
-}
-//# sourceMappingURL=proxy.js.map

package/dist/token/factory.d.ts

@@ -1,41 +0,0 @@
-import type { ToolsLogger } from '@sap-ux/logger';
-import type { ServiceKeys } from '@sap-ux/adp-tooling';
-import { OAuthTokenProvider } from './provider';
-import type { CfOAuthMiddlewareConfig } from '../types';
-/**
- * Creates an OAuthTokenProvider from service keys (extracted from Cloud Foundry service instance).
- *
- * @param {ServiceKeys} serviceKeys - Service keys containing UAA information.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {OAuthTokenProvider} OAuthTokenProvider instance.
- * @throws {Error} If service keys are invalid.
- */
-export declare function createManagerFromServiceKeys(serviceKeys: ServiceKeys, logger: ToolsLogger): OAuthTokenProvider;
-/**
- * Creates an OAuthTokenProvider from direct OAuth credentials (provided in configuration).
- *
- * @param {string} clientId - OAuth2 client ID.
- * @param {string} clientSecret - OAuth2 client secret.
- * @param {string} baseUrl - Base URL for the OAuth service (token endpoint will be constructed as {baseUrl}/oauth/token).
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {OAuthTokenProvider} OAuthTokenProvider instance.
- */
-export declare function createManagerFromDirectCredentials(clientId: string, clientSecret: string, baseUrl: string, logger: ToolsLogger): OAuthTokenProvider;
-/**
- * Creates an OAuth token provider based on configuration.
- *
- * @param {CfOAuthMiddlewareConfig} config - Configuration options.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {Promise<OAuthTokenProvider>} Token provider instance.
- * @throws {Error} If token provider cannot be created.
- */
-export declare function createTokenProvider(config: CfOAuthMiddlewareConfig, logger: ToolsLogger): Promise<OAuthTokenProvider>;
-/**
- * Creates an OAuthTokenProvider from CF ADP project configuration (auto-detection).
- *
- * @param {string} projectPath - Path to the project root.
- * @param {ToolsLogger} logger - Logger instance.
- * @returns {Promise<OAuthTokenProvider>} Token provider instance.
- */
-export declare function createManagerFromCfAdpProject(projectPath: string, logger: ToolsLogger): Promise<OAuthTokenProvider>;
-//# sourceMappingURL=factory.d.ts.map