@virtru/dsp-sdk 0.5.0 → 0.6.0

package/lib-commonjs/src/lib/fips-crypto-service.js

@@ -1,57 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Virtru Corporation.  All rights reserved.
- *
- * Your use of this file is governed by the Virtu Terms of Service <https://www.virtru.com/terms-of-service/>.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FipsCryptoService = exports.exportPrivateKeyPem = exports.importPrivateKey = exports.unwrapSymmetricKey = exports.unwrapPrivateKey = exports.unwrapPublicKey = exports.wrapKeyPair = exports.wrapSymmetricKey = exports.wrapPrivateKey = exports.wrapPublicKey = exports.initializeFipsCrypto = void 0;
-const singlecontainer_1 = require("@opentdf/sdk/singlecontainer");
-var primitives_1 = require("./fips-crypto/primitives");
-Object.defineProperty(exports, "initializeFipsCrypto", { enumerable: true, get: function () { return primitives_1.initializeFipsCrypto; } });
-var keys_1 = require("./fips-crypto/keys");
-Object.defineProperty(exports, "wrapPublicKey", { enumerable: true, get: function () { return keys_1.wrapPublicKey; } });
-Object.defineProperty(exports, "wrapPrivateKey", { enumerable: true, get: function () { return keys_1.wrapPrivateKey; } });
-Object.defineProperty(exports, "wrapSymmetricKey", { enumerable: true, get: function () { return keys_1.wrapSymmetricKey; } });
-Object.defineProperty(exports, "wrapKeyPair", { enumerable: true, get: function () { return keys_1.wrapKeyPair; } });
-Object.defineProperty(exports, "unwrapPublicKey", { enumerable: true, get: function () { return keys_1.unwrapPublicKey; } });
-Object.defineProperty(exports, "unwrapPrivateKey", { enumerable: true, get: function () { return keys_1.unwrapPrivateKey; } });
-Object.defineProperty(exports, "unwrapSymmetricKey", { enumerable: true, get: function () { return keys_1.unwrapSymmetricKey; } });
-const primitives_2 = require("./fips-crypto/primitives");
-const symmetric_1 = require("./fips-crypto/symmetric");
-const asymmetric_1 = require("./fips-crypto/asymmetric");
-const key_format_1 = require("./fips-crypto/key-format");
-var key_format_2 = require("./fips-crypto/key-format");
-Object.defineProperty(exports, "importPrivateKey", { enumerable: true, get: function () { return key_format_2.importPrivateKey; } });
-Object.defineProperty(exports, "exportPrivateKeyPem", { enumerable: true, get: function () { return key_format_2.exportPrivateKeyPem; } });
-// ─── FipsCryptoService ────────────────────────────────────────────────────────
-exports.FipsCryptoService = {
-    name: 'FipsCryptoService',
-    method: 'http://www.w3.org/2001/04/xmlenc#aes256-cbc',
-    decrypt: symmetric_1.decrypt,
-    decryptWithPrivateKey: asymmetric_1.decryptWithPrivateKey,
-    encrypt: symmetric_1.encrypt,
-    encryptWithPublicKey: asymmetric_1.encryptWithPublicKey,
-    generateKey: symmetric_1.generateKey,
-    generateKeyPair: asymmetric_1.generateKeyPair,
-    generateSigningKeyPair: asymmetric_1.generateSigningKeyPair,
-    randomBytes: primitives_2.randomBytes,
-    sign: asymmetric_1.sign,
-    verify: asymmetric_1.verify,
-    hmac: symmetric_1.hmac,
-    verifyHmac: symmetric_1.verifyHmac,
-    digest: primitives_2.digest,
-    generateECKeyPair: asymmetric_1.generateECKeyPair,
-    deriveKeyFromECDH: asymmetric_1.deriveKeyFromECDH,
-    importPublicKey: key_format_1.importPublicKey,
-    importPrivateKey: key_format_1.importPrivateKey,
-    exportPublicKeyPem: key_format_1.exportPublicKeyPem,
-    exportPrivateKeyPem: key_format_1.exportPrivateKeyPem,
-    exportPublicKeyJwk: key_format_1.exportPublicKeyJwk,
-    parsePublicKeyPem: key_format_1.parsePublicKeyPem,
-    extractPublicKeyPem: key_format_1.extractPublicKeyPem,
-    jwkToPublicKeyPem: key_format_1.jwkToPublicKeyPem,
-    importSymmetricKey: symmetric_1.importSymmetricKey,
-    splitSymmetricKey: symmetric_1.splitSymmetricKey,
-    mergeSymmetricKeys: symmetric_1.mergeSymmetricKeys,
-};

package/lib-commonjs/src/lib/utils.js

@@ -1,401 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Virtru Corporation.  All rights reserved.
- *
- * Your use of this file is governed by the Virtu Terms of Service <https://www.virtru.com/terms-of-service/>.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenObligations = exports.getObligations = void 0;
-exports.createAuthInterceptor = createAuthInterceptor;
-exports.createAuthProvider = createAuthProvider;
-exports.createOpenTDFClient = createOpenTDFClient;
-exports.getUserEntitlements = getUserEntitlements;
-exports.getTrustedCertificates = getTrustedCertificates;
-exports.validateJWSCertificateChain = validateJWSCertificateChain;
-const sdk_1 = require("@opentdf/sdk");
-const singlecontainer_1 = require("@opentdf/sdk/singlecontainer");
-const platform_1 = require("@opentdf/sdk/platform");
-const common_pb_js_1 = require("@opentdf/sdk/platform/common/common_pb.js");
-const asn1js = require("asn1js");
-const pkijs = require("pkijs");
-const consts_1 = require("./consts");
-const client_1 = require("./client");
-/**
- * Creates an interceptor that adds authentication headers to outgoing requests.
- *
- * This function uses the provided `AuthProvider` to generate authentication credentials
- * for each request. The `AuthProvider` is expected to implement a `withCreds` method
- * that returns an object containing authentication headers. These headers are then
- * added to the request before it is sent to the server.
- *
- * @param authProvider - An instance of `AuthProvider` used to generate authentication credentials.
- * @returns An `Interceptor` function that modifies requests to include authentication headers.
- */
-function createAuthInterceptor(authProvider, _cryptoService) {
-    return (next) => async (req) => {
-        const url = new URL(req.url);
-        const pathOnly = url.pathname;
-        // Signs only the path of the url in the request
-        const token = await authProvider.withCreds({
-            url: pathOnly,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        });
-        Object.entries(token.headers).forEach(([key, value]) => {
-            req.header.set(key, value);
-        });
-        return await next(req);
-    };
-}
-/** Creates a new instance of an OIDC Auth Provider consumed by the TDF Clients */
-async function createAuthProvider(options) {
-    const { oidc, refreshToken } = options;
-    return await sdk_1.AuthProviders.refreshAuthProvider({
-        clientId: oidc.clientId,
-        exchange: 'refresh',
-        refreshToken: refreshToken,
-        // TODO(DSPX-1559): Clean up these URLs.
-        oidcOrigin: 'https://only-required-for-back-compat.invalid',
-        oidcTokenEndpoint: oidc.tokenEndpoint,
-        oidcUserInfoEndpoint: oidc.userInfoEndpoint,
-    });
-}
-async function createOpenTDFClient(options) {
-    const { platformEndpoint, obligations, ...authProviderOptions } = options;
-    return new sdk_1.OpenTDF({
-        authProvider: await createAuthProvider(authProviderOptions),
-        platformUrl: platformEndpoint,
-        policyEndpoint: platformEndpoint,
-        defaultCreateOptions: {
-            defaultKASEndpoint: `${platformEndpoint}/kas`,
-        },
-        defaultReadOptions: {
-            fulfillableObligationFQNs: obligations,
-            // NOTE(DSP-249): Disabling assertion verification until all generated assertions are supported.
-            noVerify: true,
-        },
-        disableDPoP: true,
-        cryptoService: options.cryptoService,
-    });
-}
-const getObligations = async (ciphertext, options) => {
-    const client = await createOpenTDFClient(options);
-    const source = {
-        type: 'buffer',
-        location: new Uint8Array(ciphertext),
-    };
-    const tdfReader = client.open({ source });
-    let obligations = [];
-    try {
-        obligations = (await tdfReader.obligations()).fqns;
-    }
-    catch (error) {
-        if (error instanceof sdk_1.PermissionDeniedError) {
-            obligations = error.requiredObligations || [];
-        }
-        // Swallow other errors and return empty obligations.
-    }
-    return obligations;
-};
-exports.getObligations = getObligations;
-async function getUserEntitlements(options) {
-    const authProvider = await createAuthProvider({
-        oidc: options.oidc,
-        refreshToken: options.refreshToken,
-        cryptoService: options.cryptoService,
-    });
-    const accessToken = await authProvider.oidcAuth.get();
-    const userEntitlementsResponse = await fetch(`${options.platformEndpoint}/shared/entitlements`, {
-        body: JSON.stringify({}),
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json',
-        },
-        method: 'POST',
-    });
-    return (await userEntitlementsResponse.json());
-}
-const flattenObligations = (obligations) => Object.values(obligations).flatMap((feature) => feature?.fully_qualified_names || []);
-exports.flattenObligations = flattenObligations;
-/**
- * Helper function to retrieve certificates for a specific namespace with pagination handling.
- *
- * This function automatically handles pagination to retrieve all certificates for a namespace,
- * making multiple requests if necessary.
- *
- * @param dspClient - The DSP client instance.
- * @param namespaceId - The namespace UUID.
- * @returns A promise that resolves to an array of certificates for the namespace.
- * @throws If there is an error retrieving the certificates from the CertificateService.
- */
-async function getCertificatesForNamespace(dspClient, namespaceId) {
-    const certificates = [];
-    let offset = 0;
-    const limit = 100;
-    while (true) {
-        const response = await dspClient.v1.certificateService.listCertificatesByNamespace({
-            namespaceId,
-            pagination: { limit, offset },
-        });
-        if (response.certificates?.length > 0) {
-            certificates.push(...response.certificates);
-        }
-        // Check for more pages
-        if (response.pagination?.nextOffset && response.pagination.nextOffset > 0) {
-            offset = response.pagination.nextOffset;
-        }
-        else {
-            break;
-        }
-    }
-    return certificates;
-}
-/**
- * Retrieves all trusted certificates from active namespaces in the platform.
- *
- * This function uses the new CertificateService API to retrieve certificates from all active
- * namespaces. It automatically handles pagination to ensure all certificates are retrieved.
- *
- * The function performs the following steps:
- * 1. Creates an authenticated auth provider with DPoP signing keys
- * 2. Lists all active namespaces using the PlatformClient
- * 3. For each namespace, retrieves all associated certificates using the CertificateService
- * 4. Aggregates and returns all certificates from all namespaces
- *
- * @param options - The options object containing the platform endpoint, OIDC configuration, and refresh token.
- * @param options.oidc - The OIDC configuration object.
- * @param options.oidc.clientId - The OIDC client ID.
- * @param options.oidc.tokenEndpoint - The OIDC token endpoint URL.
- * @param options.oidc.userInfoEndpoint - The OIDC user info endpoint URL.
- * @param options.platformEndpoint - The base URL of the platform.
- * @param options.refreshToken - The refresh token for authentication.
- * @returns A promise that resolves to an array of trusted certificates from all active namespaces.
- * @throws If there is an error retrieving namespaces or certificates.
- *
- * @example
- * ```typescript
- * const certificates = await getTrustedCertificates({
- *   oidc: {
- *     clientId: 'my-client-id',
- *     tokenEndpoint: 'https://auth.example.com/token',
- *     userInfoEndpoint: 'https://auth.example.com/userinfo',
- *   },
- *   platformEndpoint: 'https://platform.example.com',
- *   refreshToken: 'my-refresh-token',
- * });
- * ```
- */
-async function getTrustedCertificates(options) {
-    const cs = options.cryptoService ?? singlecontainer_1.WebCryptoService;
-    const authProvider = await createAuthProvider({
-        oidc: options.oidc,
-        refreshToken: options.refreshToken,
-        cryptoService: options.cryptoService,
-    });
-    await authProvider.updateClientPublicKey(await cs.generateSigningKeyPair());
-    // Create both clients
-    const platform = new platform_1.PlatformClient({
-        authProvider,
-        platformUrl: options.platformEndpoint,
-    });
-    const dspClient = new client_1.DSPClient({
-        platformUrl: options.platformEndpoint,
-        authProvider,
-    });
-    const certificates = [];
-    try {
-        // Get active namespaces (still using namespace API)
-        const namespaces = await platform.v1.namespace.listNamespaces({
-            state: common_pb_js_1.ActiveStateEnum.ACTIVE,
-        });
-        // Get certificates using new CertificateService API
-        for (const namespace of namespaces.namespaces) {
-            const namespaceCerts = await getCertificatesForNamespace(dspClient, namespace.id);
-            certificates.push(...namespaceCerts);
-        }
-    }
-    catch (error) {
-        throw error;
-    }
-    return certificates;
-}
-/**
- * Helper to get a string representation of a pkijs Name.
- */
-function getNameStringSafe(name) {
-    if (!name)
-        return '';
-    try {
-        // pkijs Name to string can be derived from typesAndValues
-        const parts = (name.typesAndValues || []).map((tv) => {
-            const type = tv?.type ?? 'unknownType';
-            // tv.value is an ASN.1 value; best-effort toString fallback
-            let value;
-            try {
-                const block = tv?.value?.valueBlock;
-                const v = block?.value;
-                value = typeof v === 'string' ? v : String(tv?.value);
-            }
-            catch {
-                value = '<?>';
-            }
-            return `${type}=${value}`;
-        });
-        return parts.join(', ');
-    }
-    catch {
-        return '';
-    }
-}
-function base64ToArrayBuffer(b64) {
-    const normalized = b64.replace(/\s+/g, '');
-    // Basic sanity check; allow trailing '=' padding
-    if (!/^[-A-Za-z0-9+/]*=*$/.test(normalized)) {
-        throw new Error('Invalid base64 characters');
-    }
-    // Optional size guard (approx: 3/4 of base64 length is bytes)
-    const approxBytes = Math.floor((normalized.length * 3) / 4);
-    if (approxBytes === 0) {
-        throw new Error('Empty base64 data');
-    }
-    if (approxBytes > consts_1.MAX_CERT_BYTES) {
-        throw new Error(`Certificate exceeds maximum allowed size of ${consts_1.MAX_CERT_BYTES} bytes`);
-    }
-    const binaryString = atob(normalized);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes.buffer; // bytes is freshly allocated; buffer is tightly packed
-}
-function pemToArrayBuffer(pem) {
-    const base64Der = pem
-        .replace(/-----BEGIN CERTIFICATE-----/g, '')
-        .replace(/-----END CERTIFICATE-----/g, '')
-        .replace(/\r?\n|\r|\s/g, '');
-    return base64ToArrayBuffer(base64Der);
-}
-/**
- * Validate that a certificate chain from JWS x5c header chains to a trusted root.
- *
- * This function is designed to be portable and can be moved to another repository.
- * It validates that the certificate chain presented in a JWS x5c header builds a
- * valid chain to one of the provided trusted root certificates.
- *
- * Expectations and behavior:
- * - `x5c` must be ordered leaf-first and contain base64-encoded DER certs.
- * - `trustedRootCertificates` should contain PEM-encoded root certificates.
- * - Performs basic input size checks and safe base64 decoding.
- * - Uses PKI.js `CertificateChainValidationEngine` for comprehensive path validation
- *   (validity dates, signatures, policies when present, etc.).
- * - Returns detailed error messages including the leaf subject/issuer and parsing warnings.
- *
- * @param x5c - Array of base64-encoded DER certificates from JWS header (leaf first)
- * @param trustedRootCertificates - Array of Certificate objects containing trusted roots in PEM format
- * @returns Object with validation result and warnings
- * @throws {Error} if validation fails
- *
- * @example
- * ```typescript
- * try {
- *   const result = await validateJWSCertificateChain(
- *     jwsHeader.x5c,
- *     namespaceCertificates
- *   );
- *   console.log('Chain validates to trusted root', result.validationResult.warnings);
- * } catch (error) {
- *   console.error('Validation failed:', error.message);
- * }
- * ```
- */
-async function validateJWSCertificateChain(x5c, trustedRootCertificates, _cryptoService) {
-    const warnings = [];
-    try {
-        // Validate inputs
-        if (!Array.isArray(x5c) || x5c.length === 0) {
-            throw new Error('No certificates provided in x5c array');
-        }
-        if (x5c.length > consts_1.MAX_CERTS) {
-            throw new Error(`Too many certificates in x5c (max ${consts_1.MAX_CERTS})`);
-        }
-        if (!Array.isArray(trustedRootCertificates) ||
-            trustedRootCertificates.length === 0) {
-            throw new Error('No trusted root certificates provided');
-        }
-        // Parse chain certs (base64 DER)
-        const chainCertificates = [];
-        for (let i = 0; i < x5c.length; i++) {
-            const certBase64 = x5c[i];
-            try {
-                const certBuffer = base64ToArrayBuffer(certBase64);
-                const asn1 = asn1js.fromBER(certBuffer);
-                if (asn1.offset === -1) {
-                    throw new Error(`Invalid DER encoding for certificate at x5c[${i}]`);
-                }
-                chainCertificates.push(new pkijs.Certificate({ schema: asn1.result }));
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : 'Unknown error';
-                throw new Error(`Failed to parse certificate at x5c[${i}]: ${msg}`);
-            }
-        }
-        // Parse trusted roots (PEM)
-        const trustedCerts = [];
-        for (let i = 0; i < trustedRootCertificates.length; i++) {
-            const rootCert = trustedRootCertificates[i];
-            try {
-                const pem = rootCert.pem;
-                if (!pem || pem.trim().length === 0) {
-                    warnings.push(`Trusted root at index ${i} has no PEM data; skipping`);
-                    continue;
-                }
-                const certBuffer = pemToArrayBuffer(pem);
-                const asn1 = asn1js.fromBER(certBuffer);
-                if (asn1.offset === -1) {
-                    warnings.push(`Trusted root at index ${i} has invalid DER; skipping`);
-                    continue;
-                }
-                trustedCerts.push(new pkijs.Certificate({ schema: asn1.result }));
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : 'Unknown error';
-                warnings.push(`Failed to parse trusted root at index ${i}: ${msg}`);
-            }
-        }
-        if (trustedCerts.length === 0) {
-            throw new Error('No valid trusted root certificates could be parsed');
-        }
-        // Build and verify certificate chain using PKI.js
-        const chainEngine = new pkijs.CertificateChainValidationEngine({
-            trustedCerts,
-            certs: chainCertificates,
-            checkDate: new Date(),
-        });
-        const verificationResult = await chainEngine.verify();
-        if (!verificationResult.result) {
-            // Compose detailed message
-            const leaf = chainCertificates[0];
-            const leafSubject = getNameStringSafe(leaf.subject);
-            const leafIssuer = getNameStringSafe(leaf.issuer);
-            const baseMsg = verificationResult.resultMessage ||
-                'Certificate chain validation failed';
-            throw new Error(`${baseMsg} (leaf subject='${leafSubject}', issuer='${leafIssuer}')`);
-        }
-        return {
-            valid: true,
-            validationResult: {
-                warnings,
-                errors: [],
-            },
-        };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : 'Unknown error';
-        const warnSuffix = warnings.length
-            ? `; warnings: ${warnings.join(' | ')}`
-            : '';
-        throw new Error(`Validation error: ${msg}${warnSuffix}`);
-    }
-}

package/lib-commonjs/tests/dsp-client.test.js

@@ -1,75 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Virtru Corporation.  All rights reserved.
- *
- * Your use of this file is governed by the Virtu Terms of Service <https://www.virtru.com/terms-of-service/>.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const index_1 = require("../src/index");
-const tagging_pdp_tag_1 = require("./mocks/tagging-pdp-tag");
-const create_export_artifacts_1 = require("./mocks/create-export-artifacts");
-const platformUrl = 'https://dsp.example.com';
-// Mock fetch globally
-const mockFetch = vitest_1.vi.fn();
-global.fetch = mockFetch;
-(0, vitest_1.beforeEach)(() => {
-    mockFetch.mockReset();
-    // Setup default mock responses
-    mockFetch.mockImplementation(async (url) => {
-        if (url.includes('/tagging.pdp.v2.TaggingPDPService/Tag')) {
-            return {
-                ok: true,
-                status: 200,
-                json: async () => (0, tagging_pdp_tag_1.mockTaggingPDPResponse)(),
-                headers: new Headers({
-                    'Content-Type': 'application/json',
-                }),
-            };
-        }
-        if (url.includes('/policyimportexport.v1.PolicyArtifactService/CreateExportArtifacts')) {
-            return {
-                ok: true,
-                status: 200,
-                json: async () => (0, create_export_artifacts_1.mockCreateExportArtifactsResponse)(),
-                headers: new Headers({
-                    'Content-Type': 'application/json',
-                }),
-            };
-        }
-        return {
-            ok: false,
-            status: 404,
-            json: async () => ({}),
-            headers: new Headers(),
-        };
-    });
-});
-(0, vitest_1.test)('should create a new DSPClient instance with platformUrl', async () => {
-    const client = new index_1.DSPClient({ platformUrl });
-    (0, vitest_1.expect)(client).toBeInstanceOf(index_1.DSPClient);
-});
-(0, vitest_1.test)('should throw an error if platformUrl is not provided', async () => {
-    (0, vitest_1.expect)(() => new index_1.DSPClient({})).toThrowError('platformUrl is required for DSP client');
-});
-(0, vitest_1.test)('should perform RPC calls using the taggingPDPService', async () => {
-    const client = new index_1.DSPClient({ platformUrl });
-    (0, vitest_1.expect)(client).toBeInstanceOf(index_1.DSPClient);
-    const result = await client.v2.taggingPDPService.tag({});
-    (0, vitest_1.expect)(result.$typeName).toBe('tagging.pdp.v2.TaggingPDPResponse');
-});
-(0, vitest_1.test)('should perform RPC calls using the policyArtifactService', async () => {
-    const client = new index_1.DSPClient({ platformUrl });
-    (0, vitest_1.expect)(client).toBeInstanceOf(index_1.DSPClient);
-    const result = await client.v1.policyArtifactService.createExportArtifacts({});
-    (0, vitest_1.expect)(result.$typeName).toBe('policyimportexport.v1.CreateExportArtifactsResponse');
-});
-(0, vitest_1.test)('should use provided interceptors when making RPC calls', async () => {
-    const mockInterceptor = vitest_1.vi.fn((next) => next);
-    const client = new index_1.DSPClient({
-        platformUrl,
-        interceptors: [mockInterceptor],
-    });
-    await client.v2.taggingPDPService.tag({});
-    (0, vitest_1.expect)(mockInterceptor).toHaveBeenCalled();
-});

package/lib-commonjs/tests/dsp.test.js

@@ -1,94 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Virtru Corporation.  All rights reserved.
- *
- * Your use of this file is governed by the Virtu Terms of Service <https://www.virtru.com/terms-of-service/>.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const src_1 = require("../src");
-const tagging_pdp_tag_1 = require("./mocks/tagging-pdp-tag");
-const sdk_1 = require("@opentdf/sdk");
-const well_known_configuration_1 = require("./mocks/well-known-configuration");
-const platformUrl = 'https://dsp.example.com';
-// Mock fetch globally
-const mockFetch = vitest_1.vi.fn();
-global.fetch = mockFetch;
-const authProvider = {
-    updateClientPublicKey: async () => { },
-    withCreds: async (req) => (0, sdk_1.withHeaders)(req, {
-        Authorization: 'Bearer dummy auth token for testing purposes',
-    }),
-};
-(0, vitest_1.beforeEach)(() => {
-    mockFetch.mockReset();
-    // Setup default mock responses
-    mockFetch.mockImplementation(async (url) => {
-        if (url.includes('/tagging.pdp.v2.TaggingPDPService/Tag')) {
-            return {
-                ok: true,
-                status: 200,
-                json: async () => (0, tagging_pdp_tag_1.mockTaggingPDPResponse)(),
-                headers: new Headers({
-                    'Content-Type': 'application/json',
-                }),
-            };
-        }
-        if (url.includes('/wellknownconfiguration.WellKnownService/GetWellKnownConfiguration')) {
-            return {
-                ok: true,
-                status: 200,
-                json: async () => (0, well_known_configuration_1.mockWellKnownConfiguration)(),
-                headers: new Headers({
-                    'Content-Type': 'application/json',
-                }),
-            };
-        }
-        return {
-            ok: false,
-            status: 404,
-            json: async () => ({}),
-            headers: new Headers(),
-        };
-    });
-});
-(0, vitest_1.test)('should create a new DSP instance with platformUrl', () => {
-    const dsp = new src_1.DSP({ platformUrl, authProvider });
-    (0, vitest_1.expect)(dsp).toBeInstanceOf(src_1.DSP);
-});
-(0, vitest_1.test)('should throw an error if platformUrl is not provided', () => {
-    (0, vitest_1.expect)(() => new src_1.DSP({ authProvider })).toThrowError('platformUrl is required for DSP client');
-});
-(0, vitest_1.test)('should create a new DSP instance with platformUrl and authProvider', () => {
-    const dsp = new src_1.DSP({ platformUrl, authProvider });
-    (0, vitest_1.expect)(dsp).toBeInstanceOf(src_1.DSP);
-});
-(0, vitest_1.test)('should perform RPC calls using the DSP client service', async () => {
-    const dsp = new src_1.DSP({ platformUrl, authProvider });
-    const result = await dsp.services.v2.taggingPDPService.tag({});
-    (0, vitest_1.expect)(result.$typeName).toBe('tagging.pdp.v2.TaggingPDPResponse');
-});
-(0, vitest_1.test)('should perform RPC calls via internal PlatformClient service', async () => {
-    const dsp = new src_1.DSP({ platformUrl, authProvider });
-    const result = await dsp.services.v1.wellknown.getWellKnownConfiguration({});
-    (0, vitest_1.expect)(result.$typeName).toBe('wellknownconfiguration.GetWellKnownConfigurationResponse');
-});
-(0, vitest_1.test)('should use provided interceptors when making RPC calls', async () => {
-    const mockInterceptor = vitest_1.vi.fn((next) => next);
-    const dsp = new src_1.DSP({
-        platformUrl,
-        authProvider,
-        interceptors: [mockInterceptor],
-    });
-    await dsp.services.v2.taggingPDPService.tag({});
-    (0, vitest_1.expect)(mockInterceptor).toHaveBeenCalled();
-});
-(0, vitest_1.test)('should expose expected service structure', () => {
-    const dsp = new src_1.DSP({ platformUrl, authProvider });
-    (0, vitest_1.expect)(dsp.services).toHaveProperty('v1');
-    (0, vitest_1.expect)(dsp.services.v2).toHaveProperty('taggingPDPService');
-    (0, vitest_1.expect)(dsp.services.v1).toHaveProperty('wellknown');
-});
-(0, vitest_1.test)('should throw if authProvider is missing', () => {
-    (0, vitest_1.expect)(() => new src_1.DSP({ platformUrl })).toThrowError('Client ID or custom AuthProvider must be defined');
-});