@salesforce/b2c-cli 0.0.7 → 0.1.0

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/index.d.ts

@@ -1,127 +0,0 @@
-/**
- * API clients for B2C Commerce operations.
- *
- * This module provides typed client classes for interacting with B2C Commerce
- * APIs including WebDAV, OCAPI, SCAPI, and ODS.
- *
- * ## Available Clients
- *
- * - {@link WebDavClient} - File operations via WebDAV
- * - {@link OcapiClient} - Data API operations via OCAPI (openapi-fetch Client)
- * - {@link SlasClient} - SLAS Admin API for managing tenants and clients
- * - {@link OdsClient} - On-Demand Sandbox API for managing developer sandboxes
- * - {@link CustomApisClient} - Custom APIs DX API for retrieving endpoint status
- *
- * ## Usage
- *
- * **Note:** These clients are typically accessed via `B2CInstance` rather than
- * instantiated directly. The `B2CInstance` class handles authentication setup
- * and provides convenient `webdav` and `ocapi` getters.
- *
- * ```typescript
- * import { resolveConfig } from '@salesforce/b2c-tooling-sdk/config';
- *
- * const config = resolveConfig({
- *   clientId: process.env.SFCC_CLIENT_ID,
- *   clientSecret: process.env.SFCC_CLIENT_SECRET,
- * });
- * const instance = config.createB2CInstance();
- *
- * // WebDAV operations via instance.webdav
- * await instance.webdav.put('Cartridges/v1/app.zip', content);
- *
- * // OCAPI operations via instance.ocapi (openapi-fetch)
- * const { data } = await instance.ocapi.GET('/sites', {});
- * ```
- *
- * ## Direct Client Usage
- *
- * For advanced use cases, clients can be instantiated directly:
- *
- * ```typescript
- * import { WebDavClient, createOcapiClient, createSlasClient } from '@salesforce/b2c-tooling-sdk/clients';
- *
- * const webdav = new WebDavClient('sandbox.demandware.net', authStrategy);
- * const ocapi = createOcapiClient('sandbox.demandware.net', authStrategy);
- *
- * // SLAS client for managing SLAS clients and tenants
- * const slas = createSlasClient({ shortCode: 'kv7kzm78' }, oauthStrategy);
- * ```
- *
- * ## Creating New API Clients
- *
- * API clients follow a consistent pattern using
- * {@link https://openapi-ts.dev/openapi-fetch/ | openapi-fetch} for type-safe
- * HTTP requests and {@link https://openapi-ts.dev/ | openapi-typescript} for
- * generating TypeScript types from OpenAPI specifications.
- *
- * ### Step 1: Add the OpenAPI Specification
- *
- * Place the OpenAPI spec (JSON or YAML) in `specs/`:
- *
- * ```
- * packages/b2c-tooling/specs/my-api-v1.yaml
- * ```
- *
- * ### Step 2: Generate TypeScript Types
- *
- * Add a generation command to `package.json` and run it:
- *
- * ```bash
- * openapi-typescript specs/my-api-v1.yaml -o src/clients/my-api.generated.ts
- * ```
- *
- * ### Step 3: Create the Client Module
- *
- * Create a new client file following this pattern:
- *
- * ```typescript
- * // src/clients/my-api.ts
- * import createClient, { type Client } from 'openapi-fetch';
- * import type { AuthStrategy } from '../auth/types.js';
- * import type { paths, components } from './my-api.generated.js';
- * import { createAuthMiddleware, createLoggingMiddleware } from './middleware.js';
- *
- * export type { paths, components };
- * export type MyApiClient = Client<paths>;
- *
- * export function createMyApiClient(config: MyApiConfig, auth: AuthStrategy): MyApiClient {
- *   const client = createClient<paths>({
- *     baseUrl: `https://${config.host}/api/v1`,
- *   });
- *
- *   // Add middleware - auth first, logging last (so logging sees complete request)
- *   client.use(createAuthMiddleware(auth));
- *   client.use(createLoggingMiddleware('MYAPI'));
- *
- *   return client;
- * }
- * ```
- *
- * ### Conventions
- *
- * - **Factory function**: Use `createXxxClient()` pattern (not classes)
- * - **Type exports**: Re-export `paths` and `components` for consumers
- * - **Client type**: Export a type alias `XxxClient = Client<paths>`
- * - **Middleware order**: Logging first, then auth (auth runs last on request)
- * - **Log prefix**: Use short, uppercase identifier (e.g., 'OCAPI', 'SLAS', 'SCAPI')
- * - **Generated files**: Name as `xxx.generated.ts` to indicate auto-generation
- *
- * @module clients
- */
-export { WebDavClient } from './webdav.js';
-export type { PropfindEntry, WebDavClientOptions } from './webdav.js';
-export { createAuthMiddleware, createLoggingMiddleware, createExtraParamsMiddleware } from './middleware.js';
-export type { ExtraParamsConfig, LoggingMiddlewareConfig } from './middleware.js';
-export { MiddlewareRegistry, globalMiddlewareRegistry } from './middleware-registry.js';
-export type { HttpClientType, HttpMiddlewareProvider, UnifiedMiddleware } from './middleware-registry.js';
-export { createOcapiClient } from './ocapi.js';
-export type { OcapiClient, OcapiClientOptions, OcapiError, OcapiResponse, paths as OcapiPaths, components as OcapiComponents, } from './ocapi.js';
-export { createSlasClient } from './slas-admin.js';
-export type { SlasClient, SlasClientConfig, SlasError, SlasResponse, paths as SlasPaths, components as SlasComponents, } from './slas-admin.js';
-export { createOdsClient } from './ods.js';
-export type { OdsClient, OdsClientConfig, OdsError, OdsResponse, paths as OdsPaths, components as OdsComponents, } from './ods.js';
-export { createMrtClient, DEFAULT_MRT_ORIGIN } from './mrt.js';
-export type { MrtClient, MrtClientConfig, MrtError, MrtResponse, BuildPushResponse, paths as MrtPaths, components as MrtComponents, } from './mrt.js';
-export { createCustomApisClient, toOrganizationId, toTenantId, buildTenantScope, ORGANIZATION_ID_PREFIX, SCAPI_TENANT_SCOPE_PREFIX, CUSTOM_APIS_DEFAULT_SCOPES, } from './custom-apis.js';
-export type { CustomApisClient, CustomApisClientConfig, CustomApisError, CustomApisResponse, paths as CustomApisPaths, components as CustomApisComponents, } from './custom-apis.js';

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/index.js

@@ -1,125 +0,0 @@
-/*
- * Copyright (c) 2025, Salesforce, Inc.
- * SPDX-License-Identifier: Apache-2
- * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
- */
-/**
- * API clients for B2C Commerce operations.
- *
- * This module provides typed client classes for interacting with B2C Commerce
- * APIs including WebDAV, OCAPI, SCAPI, and ODS.
- *
- * ## Available Clients
- *
- * - {@link WebDavClient} - File operations via WebDAV
- * - {@link OcapiClient} - Data API operations via OCAPI (openapi-fetch Client)
- * - {@link SlasClient} - SLAS Admin API for managing tenants and clients
- * - {@link OdsClient} - On-Demand Sandbox API for managing developer sandboxes
- * - {@link CustomApisClient} - Custom APIs DX API for retrieving endpoint status
- *
- * ## Usage
- *
- * **Note:** These clients are typically accessed via `B2CInstance` rather than
- * instantiated directly. The `B2CInstance` class handles authentication setup
- * and provides convenient `webdav` and `ocapi` getters.
- *
- * ```typescript
- * import { resolveConfig } from '@salesforce/b2c-tooling-sdk/config';
- *
- * const config = resolveConfig({
- *   clientId: process.env.SFCC_CLIENT_ID,
- *   clientSecret: process.env.SFCC_CLIENT_SECRET,
- * });
- * const instance = config.createB2CInstance();
- *
- * // WebDAV operations via instance.webdav
- * await instance.webdav.put('Cartridges/v1/app.zip', content);
- *
- * // OCAPI operations via instance.ocapi (openapi-fetch)
- * const { data } = await instance.ocapi.GET('/sites', {});
- * ```
- *
- * ## Direct Client Usage
- *
- * For advanced use cases, clients can be instantiated directly:
- *
- * ```typescript
- * import { WebDavClient, createOcapiClient, createSlasClient } from '@salesforce/b2c-tooling-sdk/clients';
- *
- * const webdav = new WebDavClient('sandbox.demandware.net', authStrategy);
- * const ocapi = createOcapiClient('sandbox.demandware.net', authStrategy);
- *
- * // SLAS client for managing SLAS clients and tenants
- * const slas = createSlasClient({ shortCode: 'kv7kzm78' }, oauthStrategy);
- * ```
- *
- * ## Creating New API Clients
- *
- * API clients follow a consistent pattern using
- * {@link https://openapi-ts.dev/openapi-fetch/ | openapi-fetch} for type-safe
- * HTTP requests and {@link https://openapi-ts.dev/ | openapi-typescript} for
- * generating TypeScript types from OpenAPI specifications.
- *
- * ### Step 1: Add the OpenAPI Specification
- *
- * Place the OpenAPI spec (JSON or YAML) in `specs/`:
- *
- * ```
- * packages/b2c-tooling/specs/my-api-v1.yaml
- * ```
- *
- * ### Step 2: Generate TypeScript Types
- *
- * Add a generation command to `package.json` and run it:
- *
- * ```bash
- * openapi-typescript specs/my-api-v1.yaml -o src/clients/my-api.generated.ts
- * ```
- *
- * ### Step 3: Create the Client Module
- *
- * Create a new client file following this pattern:
- *
- * ```typescript
- * // src/clients/my-api.ts
- * import createClient, { type Client } from 'openapi-fetch';
- * import type { AuthStrategy } from '../auth/types.js';
- * import type { paths, components } from './my-api.generated.js';
- * import { createAuthMiddleware, createLoggingMiddleware } from './middleware.js';
- *
- * export type { paths, components };
- * export type MyApiClient = Client<paths>;
- *
- * export function createMyApiClient(config: MyApiConfig, auth: AuthStrategy): MyApiClient {
- *   const client = createClient<paths>({
- *     baseUrl: `https://${config.host}/api/v1`,
- *   });
- *
- *   // Add middleware - auth first, logging last (so logging sees complete request)
- *   client.use(createAuthMiddleware(auth));
- *   client.use(createLoggingMiddleware('MYAPI'));
- *
- *   return client;
- * }
- * ```
- *
- * ### Conventions
- *
- * - **Factory function**: Use `createXxxClient()` pattern (not classes)
- * - **Type exports**: Re-export `paths` and `components` for consumers
- * - **Client type**: Export a type alias `XxxClient = Client<paths>`
- * - **Middleware order**: Logging first, then auth (auth runs last on request)
- * - **Log prefix**: Use short, uppercase identifier (e.g., 'OCAPI', 'SLAS', 'SCAPI')
- * - **Generated files**: Name as `xxx.generated.ts` to indicate auto-generation
- *
- * @module clients
- */
-export { WebDavClient } from './webdav.js';
-export { createAuthMiddleware, createLoggingMiddleware, createExtraParamsMiddleware } from './middleware.js';
-export { MiddlewareRegistry, globalMiddlewareRegistry } from './middleware-registry.js';
-export { createOcapiClient } from './ocapi.js';
-export { createSlasClient } from './slas-admin.js';
-export { createOdsClient } from './ods.js';
-export { createMrtClient, DEFAULT_MRT_ORIGIN } from './mrt.js';
-export { createCustomApisClient, toOrganizationId, toTenantId, buildTenantScope, ORGANIZATION_ID_PREFIX, SCAPI_TENANT_SCOPE_PREFIX, CUSTOM_APIS_DEFAULT_SCOPES, } from './custom-apis.js';
-//# sourceMappingURL=index.js.map

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/clients/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8GG;AACH,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAC,oBAAoB,EAAE,uBAAuB,EAAE,2BAA2B,EAAC,MAAM,iBAAiB,CAAC;AAG3G,OAAO,EAAC,kBAAkB,EAAE,wBAAwB,EAAC,MAAM,0BAA0B,CAAC;AAGtF,OAAO,EAAC,iBAAiB,EAAC,MAAM,YAAY,CAAC;AAU7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAUjD,OAAO,EAAC,eAAe,EAAC,MAAM,UAAU,CAAC;AAUzC,OAAO,EAAC,eAAe,EAAE,kBAAkB,EAAC,MAAM,UAAU,CAAC;AAW7D,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC"}

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/middleware-registry.d.ts

@@ -1,184 +0,0 @@
-/**
- * HTTP Middleware Registry for B2C SDK.
- *
- * Provides a unified middleware system that works across all HTTP clients,
- * including openapi-fetch clients (OCAPI, SLAS, etc.) and the WebDAV client.
- *
- * ## SDK Usage
- *
- * ```typescript
- * import { globalMiddlewareRegistry, HttpMiddlewareProvider } from '@salesforce/b2c-tooling-sdk/clients';
- *
- * const loggingProvider: HttpMiddlewareProvider = {
- *   name: 'my-logger',
- *   getMiddleware(clientType) {
- *     return {
- *       onRequest({ request }) {
- *         console.log(`[${clientType}] ${request.method} ${request.url}`);
- *         return request;
- *       },
- *       onResponse({ response }) {
- *         console.log(`[${clientType}] ${response.status}`);
- *         return response;
- *       },
- *     };
- *   },
- * };
- *
- * globalMiddlewareRegistry.register(loggingProvider);
- * ```
- *
- * ## CLI Plugin Usage
- *
- * Plugins can provide middleware via the `b2c:http-middleware` hook.
- *
- * @module clients/middleware-registry
- */
-import type { Middleware } from 'openapi-fetch';
-/**
- * Types of HTTP clients that can receive middleware.
- */
-export type HttpClientType = 'ocapi' | 'slas' | 'ods' | 'mrt' | 'custom-apis' | 'webdav';
-/**
- * Middleware interface compatible with openapi-fetch.
- *
- * This is the same interface as openapi-fetch's Middleware, re-exported
- * for convenience. It can be used for both openapi-fetch clients and
- * the WebDAV client (which adapts it internally).
- *
- * @example
- * ```typescript
- * const middleware: UnifiedMiddleware = {
- *   async onRequest({ request }) {
- *     request.headers.set('X-Custom-Header', 'value');
- *     return request;
- *   },
- *   async onResponse({ response }) {
- *     // Inspect or modify response
- *     return response;
- *   },
- * };
- * ```
- */
-export type UnifiedMiddleware = Middleware;
-/**
- * Middleware provider that supplies middleware for HTTP clients.
- *
- * Providers can return different middleware for different client types,
- * or return `undefined` to skip certain client types.
- *
- * @example
- * ```typescript
- * const provider: HttpMiddlewareProvider = {
- *   name: 'metrics-collector',
- *   getMiddleware(clientType) {
- *     // Only collect metrics for OCAPI calls
- *     if (clientType !== 'ocapi') return undefined;
- *
- *     return {
- *       onRequest({ request }) {
- *         (request as any)._startTime = Date.now();
- *         return request;
- *       },
- *       onResponse({ request, response }) {
- *         const duration = Date.now() - (request as any)._startTime;
- *         recordMetric('ocapi_request_duration', duration);
- *         return response;
- *       },
- *     };
- *   },
- * };
- * ```
- */
-export interface HttpMiddlewareProvider {
-    /**
-     * Human-readable name for the provider (used in logging/debugging).
-     */
-    readonly name: string;
-    /**
-     * Returns middleware for a specific client type.
-     *
-     * @param clientType - The type of HTTP client requesting middleware
-     * @returns Middleware to apply, or undefined to skip this client type
-     */
-    getMiddleware(clientType: HttpClientType): UnifiedMiddleware | undefined;
-}
-/**
- * Registry for HTTP middleware providers.
- *
- * The registry collects middleware from multiple providers and returns
- * them in registration order when requested by client factories.
- *
- * ## Usage Modes
- *
- * **SDK Mode**: Register providers directly via `register()`:
- * ```typescript
- * globalMiddlewareRegistry.register(myProvider);
- * ```
- *
- * **CLI Mode**: Providers are collected via the `b2c:http-middleware` hook
- * and registered during command initialization.
- */
-export declare class MiddlewareRegistry {
-    private providers;
-    /**
-     * Registers a middleware provider.
-     *
-     * Providers are called in registration order when middleware is requested.
-     *
-     * @param provider - The provider to register
-     */
-    register(provider: HttpMiddlewareProvider): void;
-    /**
-     * Unregisters a middleware provider by name.
-     *
-     * @param name - The name of the provider to remove
-     * @returns true if a provider was removed, false if not found
-     */
-    unregister(name: string): boolean;
-    /**
-     * Collects middleware from all providers for a specific client type.
-     *
-     * @param clientType - The type of client requesting middleware
-     * @returns Array of middleware in registration order
-     */
-    getMiddleware(clientType: HttpClientType): UnifiedMiddleware[];
-    /**
-     * Clears all registered providers.
-     *
-     * Primarily useful for testing.
-     */
-    clear(): void;
-    /**
-     * Returns the number of registered providers.
-     */
-    get size(): number;
-    /**
-     * Returns the names of all registered providers.
-     */
-    getProviderNames(): string[];
-}
-/**
- * Global middleware registry instance.
- *
- * This is the default registry used by all B2C SDK clients. Register
- * middleware providers here to have them applied automatically.
- *
- * @example
- * ```typescript
- * import { globalMiddlewareRegistry } from '@salesforce/b2c-tooling-sdk/clients';
- *
- * globalMiddlewareRegistry.register({
- *   name: 'request-logger',
- *   getMiddleware() {
- *     return {
- *       onRequest({ request }) {
- *         console.log(`Request: ${request.method} ${request.url}`);
- *         return request;
- *       },
- *     };
- *   },
- * });
- * ```
- */
-export declare const globalMiddlewareRegistry: MiddlewareRegistry;

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/middleware-registry.js

@@ -1,104 +0,0 @@
-/**
- * Registry for HTTP middleware providers.
- *
- * The registry collects middleware from multiple providers and returns
- * them in registration order when requested by client factories.
- *
- * ## Usage Modes
- *
- * **SDK Mode**: Register providers directly via `register()`:
- * ```typescript
- * globalMiddlewareRegistry.register(myProvider);
- * ```
- *
- * **CLI Mode**: Providers are collected via the `b2c:http-middleware` hook
- * and registered during command initialization.
- */
-export class MiddlewareRegistry {
-    providers = [];
-    /**
-     * Registers a middleware provider.
-     *
-     * Providers are called in registration order when middleware is requested.
-     *
-     * @param provider - The provider to register
-     */
-    register(provider) {
-        this.providers.push(provider);
-    }
-    /**
-     * Unregisters a middleware provider by name.
-     *
-     * @param name - The name of the provider to remove
-     * @returns true if a provider was removed, false if not found
-     */
-    unregister(name) {
-        const index = this.providers.findIndex((p) => p.name === name);
-        if (index >= 0) {
-            this.providers.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Collects middleware from all providers for a specific client type.
-     *
-     * @param clientType - The type of client requesting middleware
-     * @returns Array of middleware in registration order
-     */
-    getMiddleware(clientType) {
-        const middleware = [];
-        for (const provider of this.providers) {
-            const m = provider.getMiddleware(clientType);
-            if (m) {
-                middleware.push(m);
-            }
-        }
-        return middleware;
-    }
-    /**
-     * Clears all registered providers.
-     *
-     * Primarily useful for testing.
-     */
-    clear() {
-        this.providers = [];
-    }
-    /**
-     * Returns the number of registered providers.
-     */
-    get size() {
-        return this.providers.length;
-    }
-    /**
-     * Returns the names of all registered providers.
-     */
-    getProviderNames() {
-        return this.providers.map((p) => p.name);
-    }
-}
-/**
- * Global middleware registry instance.
- *
- * This is the default registry used by all B2C SDK clients. Register
- * middleware providers here to have them applied automatically.
- *
- * @example
- * ```typescript
- * import { globalMiddlewareRegistry } from '@salesforce/b2c-tooling-sdk/clients';
- *
- * globalMiddlewareRegistry.register({
- *   name: 'request-logger',
- *   getMiddleware() {
- *     return {
- *       onRequest({ request }) {
- *         console.log(`Request: ${request.method} ${request.url}`);
- *         return request;
- *       },
- *     };
- *   },
- * });
- * ```
- */
-export const globalMiddlewareRegistry = new MiddlewareRegistry();
-//# sourceMappingURL=middleware-registry.js.map

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/middleware-registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware-registry.js","sourceRoot":"","sources":["../../../src/clients/middleware-registry.ts"],"names":[],"mappings":"AAmHA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,kBAAkB;IACrB,SAAS,GAA6B,EAAE,CAAC;IAEjD;;;;;;OAMG;IACH,QAAQ,CAAC,QAAgC;QACvC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,IAAY;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAC/D,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAC,UAA0B;QACtC,MAAM,UAAU,GAAwB,EAAE,CAAC;QAE3C,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACtC,MAAM,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,CAAC,EAAE,CAAC;gBACN,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,kBAAkB,EAAE,CAAC"}

package/node_modules/@salesforce/b2c-tooling-sdk/dist/esm/clients/middleware.d.ts

@@ -1,85 +0,0 @@
-/**
- * Shared middleware for openapi-fetch clients.
- *
- * Provides reusable authentication and logging middleware that can be
- * used across all API clients (OCAPI, SLAS, SCAPI, etc.).
- *
- * @module clients/middleware
- */
-import type { Middleware } from 'openapi-fetch';
-import type { AuthStrategy } from '../auth/types.js';
-/**
- * Configuration for extra parameters middleware.
- */
-export interface ExtraParamsConfig {
-    /** Extra query parameters to add to the URL */
-    query?: Record<string, string | number | boolean | undefined>;
-    /** Extra body fields to merge into JSON request bodies */
-    body?: Record<string, unknown>;
-    /** Extra HTTP headers to add to all requests */
-    headers?: Record<string, string>;
-}
-/**
- * Creates authentication middleware for openapi-fetch.
- *
- * This middleware intercepts requests and adds OAuth authentication headers
- * using the provided AuthStrategy.
- *
- * @param auth - The authentication strategy to use
- * @returns Middleware that adds auth headers to requests
- */
-export declare function createAuthMiddleware(auth: AuthStrategy): Middleware;
-/**
- * Configuration for logging middleware.
- */
-export interface LoggingMiddlewareConfig {
-    /**
-     * Prefix for log messages (e.g., 'OCAPI', 'SLAS', 'MRT').
-     */
-    prefix?: string;
-    /**
-     * Body keys to mask in logs (replaced with '...' placeholder).
-     * Useful for large payloads like base64-encoded file data.
-     * @example ['data', 'password', 'secret']
-     */
-    maskBodyKeys?: string[];
-}
-/**
- * Creates logging middleware for openapi-fetch clients.
- *
- * Logs request/response details at debug and trace levels.
- *
- * @param config - Logging configuration or prefix string for backwards compatibility
- * @returns Middleware that logs requests and responses
- *
- * @example
- * // Simple usage with just a prefix
- * client.use(createLoggingMiddleware('OCAPI'));
- *
- * @example
- * // With body masking for large payloads
- * client.use(createLoggingMiddleware({
- *   prefix: 'MRT',
- *   maskBodyKeys: ['data']  // Masks base64-encoded bundle data
- * }));
- */
-export declare function createLoggingMiddleware(config?: string | LoggingMiddlewareConfig): Middleware;
-/**
- * Creates middleware that adds extra query parameters and/or body fields to requests.
- *
- * This is useful for internal/power-user scenarios where you need to pass
- * parameters that aren't in the typed OpenAPI schema.
- *
- * @param config - Configuration with extra query and/or body params
- * @returns Middleware that adds extra params to requests
- *
- * @example
- * ```typescript
- * const client = createOdsClient(config, auth);
- * client.use(createExtraParamsMiddleware({
- *   query: { debug: 'true', internal_flag: '1' },
- *   body: { _internal: { trace: true } }
- * }));
- * ```
- */
-export declare function createExtraParamsMiddleware(config: ExtraParamsConfig): Middleware;