npm - @drttix/drt-sdk - Versions diffs - 1.3.5 → 1.4.1 - Mend

@drttix/drt-sdk 1.3.5 → 1.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (312) hide show

package/dist/cjs/src/scripts/build-all.js CHANGED Viewed

@@ -73,9 +73,80 @@ fs_1.default.writeFileSync(portalRequestPath, customRequestContent);
 console.log('✅ Replaced portal/core/request.ts with custom-request.txt');
 fs_1.default.writeFileSync(scannerRequestPath, customRequestContent);
 console.log('✅ Replaced scanner/core/request.ts with custom-request.txt');
-// Strip credential params (shopperguid/accountid/apikey) from all generated service methods.
-// DRT.init() injects these globally via OpenAPI.HEADERS, so callers never need to pass them.
-console.log('⚙️  Stripping credential params from generated services...');
+// Strip/rework credential params (shopperguid/accountid/apikey) from all generated service methods.
+//
+// Portal and scanner: DRT.init() injects these globally via OpenAPI.HEADERS,
+// so callers never need to pass them — params are removed entirely.
+//
+// Shopper: the three params collapse into a single optional trailing
+// `context?: { shopperGuid?: string; accountId?: string }` argument, resolved
+// per-call via resolveShopperHeaders(). This is what lets DRT.init({
+// shopperScope: 'per-request' }) serve many shoppers/accounts from one SDK
+// instance — see src/functions/sdkConfig.ts.
+console.log('⚙️  Stripping/reworking credential params in generated services...');
+// Finds each `public static <name>(<params>): <returnType> { <body> }` method
+// by tracking paren/brace nesting (a single regex can't express "matching
+// close paren/brace" when the body itself contains nested {}/() such as
+// `headers: {...}` or `path: {...}`). For any method whose body calls
+// resolveShopperHeaders(context) but whose parameter list doesn't already
+// declare a `context` param, appends `context?: { shopperGuid?: string;
+// accountId?: string }` as the last parameter.
+function patchMissingContextParam(src) {
+    const methodStart = /public static \w+\(/g;
+    let result = '';
+    let cursor = 0;
+    let match;
+    while ((match = methodStart.exec(src))) {
+        const parenOpen = match.index + match[0].length - 1;
+        // Walk from the opening '(' to its matching ')'.
+        let depth = 0;
+        let i = parenOpen;
+        for (; i < src.length; i++) {
+            if (src[i] === '(')
+                depth++;
+            else if (src[i] === ')') {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+        }
+        const parenClose = i;
+        // Walk forward to the method's opening '{', then to its matching '}'.
+        const braceOpen = src.indexOf('{', parenClose);
+        depth = 0;
+        let j = braceOpen;
+        for (; j < src.length; j++) {
+            if (src[j] === '{')
+                depth++;
+            else if (src[j] === '}') {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+        }
+        const braceClose = j;
+        const params = src.slice(parenOpen + 1, parenClose);
+        const body = src.slice(braceOpen + 1, braceClose);
+        if (/resolveShopperHeaders\(context\)/.test(body) && !/context\?:/.test(params)) {
+            // Indentation of an existing parameter line (the new param
+            // matches it); indentation of the ')' line (preserved as-is).
+            const paramIndentMatch = /\r?\n([^\S\r\n]+)\S/.exec(params);
+            const paramIndent = paramIndentMatch ? paramIndentMatch[1] : '        ';
+            const closeIndentMatch = /\r?\n([^\S\r\n]*)$/.exec(params);
+            const closeIndent = closeIndentMatch ? closeIndentMatch[1] : '    ';
+            const trimmedParams = params.replace(/[,\s]*$/, '');
+            const sep = trimmedParams.trim() ? ',\r\n' : '\r\n';
+            const newParams = trimmedParams +
+                sep +
+                `${paramIndent}context?: { shopperGuid?: string; accountId?: string },\r\n${closeIndent}`;
+            result += src.slice(cursor, parenOpen + 1) + newParams;
+            cursor = parenClose;
+        }
+        methodStart.lastIndex = braceClose;
+    }
+    result += src.slice(cursor);
+    return result;
+}
 function walkServices(dir) {
     const results = [];
     for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
@@ -90,28 +161,98 @@ function walkServices(dir) {
     return results;
 }
 const serviceFiles = walkServices(GENERATED_BASE);
+const shopperServicesDir = path_1.default.join(GENERATED_BASE, 'shopper', 'services');
 for (const file of serviceFiles) {
+    const isShopperService = file.startsWith(shopperServicesDir);
     let src = fs_1.default.readFileSync(file, 'utf-8');
-    let patched = src
-        // Remove param lines from function signatures
-        .replace(/\n\s*shopperguid: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
-        .replace(/\n\s*accountid: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
-        .replace(/\n\s*apikey: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
-        // Remove @param jsdoc lines
-        .replace(/\n\s*\* @param shopperguid[^\n]*/g, '')
-        .replace(/\n\s*\* @param accountid[^\n]*/g, '')
-        .replace(/\n\s*\* @param apikey[^\n]*/g, '')
-        // Remove header entries inside __request
-        .replace(/\n\s*'shopperguid': shopperguid,/g, '')
-        .replace(/\n\s*'accountid': accountid,/g, '')
-        .replace(/\n\s*'apikey': apikey,/g, '')
-        // Remove empty headers: {} blocks left behind
-        .replace(/\n\s*headers: \{\s*\},/g, '');
+    let patched;
+    if (isShopperService) {
+        patched = src
+            // Fold the shopperguid param into an optional context param
+            .replace(/\n(\s*)shopperguid: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '\n$1context?: { shopperGuid?: string; accountId?: string },')
+            // accountid/apikey are resolved from context/DRT.init() instead
+            .replace(/\n\s*accountid: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
+            .replace(/\n\s*apikey: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
+            // Rework @param jsdoc lines
+            .replace(/\n(\s*)\* @param shopperguid[^\n]*/g, '\n$1* @param context Optional per-call { shopperGuid, accountId } override. Falls back to the values passed to DRT.init().')
+            .replace(/\n\s*\* @param accountid[^\n]*/g, '')
+            .replace(/\n\s*\* @param apikey[^\n]*/g, '')
+            // Replace the credential header block with a resolver call. A few
+            // endpoints (e.g. DonationService.postDonation's ipAddress header)
+            // have an additional non-credential header — merge into those
+            // instead of emitting a second "headers:" key.
+            .replace(/\n\s*'shopperguid': shopperguid,/g, '')
+            .replace(/\n\s*'accountid': accountid,/g, '')
+            .replace(/\n\s*'apikey': apikey,/g, '')
+            .replace(/headers: \{\s*\},/g, 'headers: resolveShopperHeaders(context),')
+            .replace(/headers: \{\n(\s*)/g, 'headers: {\n$1...resolveShopperHeaders(context),\n$1')
+            // TS1016: a required parameter cannot follow an optional one.
+            // When context? was injected in place of shopperguid (which appeared
+            // before requestBody in the original spec), it ends up before a
+            // required requestBody param. Move context? to after requestBody.
+            // Note: blank "lines" between params may be orphaned \r chars (CRLF
+            // files lose the \n when accountid/apikey lines are stripped) — use
+            // [\r\n]+ to match any combination of CR/LF between the two params.
+            .replace(/\n([^\S\n]+)context\?:\s*\{\s*shopperGuid\?:\s*string;\s*accountId\?:\s*string\s*\},[\r\n]+[^\S\n]+(requestBody:\s+[^?,\r\n][^,\r\n]*),/g, (_, indent, rbPart) => `\n${indent}${rbPart},\n${indent}context?: { shopperGuid?: string; accountId?: string },`);
+        // Some endpoints (e.g. Stripe's integrator-only calls) declare no
+        // shopperguid param, so the replace above never injects a `context`
+        // parameter into their signature — yet they still call
+        // resolveShopperHeaders(context) via the headers: {} replacement,
+        // leaving a dangling reference to an undeclared `context`. Add the
+        // param to any method signature whose body calls
+        // resolveShopperHeaders(context) but doesn't already declare one.
+        // Brace/paren nesting inside method bodies (headers: {...}, path:
+        // {...}, etc.) makes this unsafe to express as a single regex, so
+        // methods are located by tracking paren depth from `public static`
+        // through the matching close-paren of the parameter list, then brace
+        // depth from the following `{` through the matching method-closing
+        // `}`.
+        patched = patchMissingContextParam(patched);
+        if (patched !== src) {
+            patched = patched.replace("import { request as __request } from '../core/request';", "import { request as __request } from '../core/request';\nimport { resolveShopperHeaders } from '../../../functions/sdkConfig';");
+        }
+    }
+    else {
+        patched = src
+            // Remove param lines from function signatures
+            .replace(/\n\s*shopperguid: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
+            .replace(/\n\s*accountid: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
+            .replace(/\n\s*apikey: string(?:\s*\|\s*undefined)?\s*(?:=\s*undefined)?,/g, '')
+            // Remove @param jsdoc lines
+            .replace(/\n\s*\* @param shopperguid[^\n]*/g, '')
+            .replace(/\n\s*\* @param accountid[^\n]*/g, '')
+            .replace(/\n\s*\* @param apikey[^\n]*/g, '')
+            // Remove header entries inside __request
+            .replace(/\n\s*'shopperguid': shopperguid,/g, '')
+            .replace(/\n\s*'accountid': accountid,/g, '')
+            .replace(/\n\s*'apikey': apikey,/g, '')
+            // Remove empty headers: {} blocks left behind
+            .replace(/\n\s*headers: \{\s*\},/g, '');
+    }
     if (patched !== src) {
         fs_1.default.writeFileSync(file, patched);
     }
 }
-console.log(`✅ Stripped credentials from ${serviceFiles.length} service files`);
+console.log(`✅ Stripped/reworked credentials in ${serviceFiles.length} service files`);
+// --- Patch portal ClientToolsTicketingLinkService to return Blob for generateFlyer
+// The AdminPortal Swagger declares this as binary/pdf but openapi-typescript-codegen
+// may still emit a non-Blob return type depending on the spec version. Patch as a safeguard.
+const flyerServicePath = path_1.default.resolve('src/generated/portal/services/ClientToolsTicketingLinkService.ts');
+if (fs_1.default.existsSync(flyerServicePath)) {
+    let flyerSrc = fs_1.default.readFileSync(flyerServicePath, 'utf-8');
+    // Remove the SuccessResponse import if present (no longer needed for this file if it was only used here)
+    const patchedFlyerSrc = flyerSrc
+        .replace(/import type \{ SuccessResponse \} from '\.\.\/models\/SuccessResponse';\n/g, '')
+        .replace(/\* @returns SuccessResponse [^\n]*\n(\s*\* @throws)/, '* @returns binary Returns the generated PDF Flyer as a blob\n$1')
+        .replace(/\): CancelablePromise<SuccessResponse> \{(\s*return __request\(OpenAPI, \{[\s\S]*?url: '\/client-tools\/ticketing-link\/flyer')/, '): CancelablePromise<Blob> {$1');
+    if (patchedFlyerSrc !== flyerSrc) {
+        fs_1.default.writeFileSync(flyerServicePath, patchedFlyerSrc);
+        console.log('✅ Patched generateFlyer return type to Blob');
+    }
+    else {
+        console.log('✅ generateFlyer already returns Blob (no patch needed)');
+    }
+}
 // --- Generate index.ts
 console.log(`🧩 Generating DRT index...`);
 const lines = [];

package/dist/cjs/src/staging/index.d.ts CHANGED Viewed

@@ -31,6 +31,7 @@ export declare const DRT: {
         product: typeof import("../generated/shopper").ProductService;
         seat: typeof import("../generated/shopper").SeatService;
         session: typeof import("../generated/shopper").SessionService;
+        stripe: typeof import("../generated/shopper").StripeService;
     };
     scanner: {
         database: typeof import("../generated/scanner").DatabaseService;

package/dist/esm/index.d.ts CHANGED Viewed

@@ -16,6 +16,7 @@ export declare const DRT: {
         product: typeof import("./src/generated/shopper").ProductService;
         seat: typeof import("./src/generated/shopper").SeatService;
         session: typeof import("./src/generated/shopper").SessionService;
+        stripe: typeof import("./src/generated/shopper").StripeService;
     };
     scanner: {
         database: typeof import("./src/generated/scanner").DatabaseService;

package/dist/esm/src/definitions/shopper.d.ts CHANGED Viewed

@@ -10,6 +10,7 @@ import { PaymentService } from "../generated/shopper";
 import { ProductService } from "../generated/shopper";
 import { SeatService } from "../generated/shopper";
 import { SessionService } from "../generated/shopper";
+import { StripeService } from "../generated/shopper";
 export declare const shopper: {
     account: typeof AccountService;
     cart: typeof CartService;
@@ -23,5 +24,6 @@ export declare const shopper: {
     product: typeof ProductService;
     seat: typeof SeatService;
     session: typeof SessionService;
+    stripe: typeof StripeService;
 };
 export * as ShopperTypes from "../generated/shopper/types";

package/dist/esm/src/definitions/shopper.js CHANGED Viewed

@@ -11,6 +11,7 @@ import { PaymentService } from "../generated/shopper/index.js";
 import { ProductService } from "../generated/shopper/index.js";
 import { SeatService } from "../generated/shopper/index.js";
 import { SessionService } from "../generated/shopper/index.js";
+import { StripeService } from "../generated/shopper/index.js";
 export const shopper = {
     account: AccountService,
     cart: CartService,
@@ -24,6 +25,7 @@ export const shopper = {
     product: ProductService,
     seat: SeatService,
     session: SessionService,
+    stripe: StripeService,
 };
 // Re-export all types as a namespace
 export * as ShopperTypes from "../generated/shopper/types.js";

package/dist/esm/src/functions/sdkConfig.d.ts CHANGED Viewed

@@ -1,7 +1,25 @@
+export type ShopperScope = 'singleton' | 'per-request';
 export interface SDKConfig {
-    shopperGuid: string;
-    accountId: string;
     apiKey: string;
+    /**
+     * Required when shopperScope is 'singleton' (the default). Optional when
+     * shopperScope is 'per-request' — in that mode these act only as a fallback
+     * default, and every shopper call may override them via a trailing
+     * `{ shopperGuid, accountId }` context argument.
+     */
+    shopperGuid?: string;
+    accountId?: string;
+    /**
+     * 'singleton' (default): shopperGuid/accountId are fixed for the lifetime of
+     * the process, exactly like today.
+     *
+     * 'per-request': shopperGuid/accountId become optional at init() time, and
+     * every shopper service method accepts an optional trailing context argument
+     * ({ shopperGuid, accountId }) so a single SDK instance can serve requests
+     * for many shoppers/accounts concurrently — the intended shape for a backend
+     * that proxies calls on behalf of arbitrary shoppers.
+     */
+    shopperScope?: ShopperScope;
 }
 /**
  * Initialize the DRT SDK with credentials.
@@ -14,7 +32,7 @@ export interface SDKConfig {
  * ```javascript
  * import { DRT } from '@drttix/drt-sdk';
  *
- * // Initialize once
+ * // Initialize once (default: singleton shopper scope)
  * DRT.init({
  *   shopperGuid: 'your-shopper-guid',
  *   accountId: 'your-account-id',
@@ -24,6 +42,18 @@ export interface SDKConfig {
  * // Now make calls without passing credentials
  * const theme = await DRT.shopper.account.getTheme();
  * ```
+ *
+ * @example
+ * ```javascript
+ * // Backend serving many shoppers/accounts from a single SDK instance
+ * DRT.init({ apiKey: 'your-api-key', shopperScope: 'per-request' });
+ *
+ * // Pass shopperGuid/accountId per call instead
+ * await DRT.shopper.product.addProduct(body, {
+ *   shopperGuid: req.shopperGuid,
+ *   accountId: req.accountId,
+ * });
+ * ```
  */
 export declare function init(config: SDKConfig): void;
 /**
@@ -35,21 +65,22 @@ export declare function isReady(): boolean;
  */
 export declare function getConfig(): SDKConfig | null;
 /**
- * Reset the SDK configuration.
+ * Get the shopperScope the SDK was initialized with ('singleton' if not yet initialized).
  */
-export declare function reset(): void;
+export declare function getShopperScope(): ShopperScope;
 /**
- * Get credentials from config, throwing if not initialized.
- * Used internally by wrapped services.
+ * Reset the SDK configuration.
  */
-export declare function getCredentials(): {
-    shopperGuid: string;
-    accountId: string;
-    apiKey: string;
-};
+export declare function reset(): void;
 /**
- * Creates a proxy that auto-injects credentials for service methods.
- * Methods that take (shopperguid, accountid, apikey, ...rest) as first 3 params
- * will have those auto-filled from the SDK config.
+ * Resolves the shopperguid/accountid/apikey headers for a single shopper API call.
+ *
+ * Used internally by every generated shopper service method. `context`, when
+ * provided, overrides the shopperGuid/accountId set at DRT.init() — this is
+ * what makes shopperScope: 'per-request' work. apiKey always comes from
+ * DRT.init(), since it identifies the calling backend, not the shopper.
  */
-export declare function createAutoCredentialsProxy<T extends object>(service: T): T;
+export declare function resolveShopperHeaders(context?: {
+    shopperGuid?: string;
+    accountId?: string;
+}): Record<string, string>;

package/dist/esm/src/functions/sdkConfig.js CHANGED Viewed

@@ -4,6 +4,7 @@ import { OpenAPI as ScannerAPI } from '../generated/scanner/core/OpenAPI.js';
 import { OpenAPI as PortalAPI } from '../generated/portal/core/OpenAPI.js';
 let isInitialized = false;
 let currentConfig = null;
+let currentShopperScope = 'singleton';
 /**
  * Initialize the DRT SDK with credentials.
  * Once initialized, these credentials will be automatically included
@@ -15,7 +16,7 @@ let currentConfig = null;
  * ```javascript
  * import { DRT } from '@drttix/drt-sdk';
  *
- * // Initialize once
+ * // Initialize once (default: singleton shopper scope)
  * DRT.init({
  *   shopperGuid: 'your-shopper-guid',
  *   accountId: 'your-account-id',
@@ -25,21 +26,44 @@ let currentConfig = null;
  * // Now make calls without passing credentials
  * const theme = await DRT.shopper.account.getTheme();
  * ```
+ *
+ * @example
+ * ```javascript
+ * // Backend serving many shoppers/accounts from a single SDK instance
+ * DRT.init({ apiKey: 'your-api-key', shopperScope: 'per-request' });
+ *
+ * // Pass shopperGuid/accountId per call instead
+ * await DRT.shopper.product.addProduct(body, {
+ *   shopperGuid: req.shopperGuid,
+ *   accountId: req.accountId,
+ * });
+ * ```
  */
 export function init(config) {
-    if (!config.shopperGuid || !config.accountId || !config.apiKey) {
-        throw new Error('DRT SDK init requires shopperGuid, accountId, and apiKey');
+    var _a;
+    if (!config.apiKey) {
+        throw new Error('DRT SDK init requires apiKey');
+    }
+    const shopperScope = (_a = config.shopperScope) !== null && _a !== void 0 ? _a : 'singleton';
+    if (shopperScope === 'singleton' && (!config.shopperGuid || !config.accountId)) {
+        throw new Error('DRT SDK init requires shopperGuid and accountId (or pass shopperScope: "per-request" to supply them per shopper call instead)');
     }
     currentConfig = config;
-    const headers = {
-        shopperguid: config.shopperGuid,
-        accountid: config.accountId,
-        apikey: config.apiKey,
-    };
-    // Set headers on all API clients
-    ShopperAPI.HEADERS = headers;
-    ScannerAPI.HEADERS = headers;
-    PortalAPI.HEADERS = headers;
+    currentShopperScope = shopperScope;
+    // Portal and scanner are always singleton-scoped: one fixed set of
+    // credentials for every call, applied globally via OpenAPI.HEADERS.
+    const sharedHeaders = { apikey: config.apiKey };
+    if (config.shopperGuid && config.accountId) {
+        sharedHeaders.shopperguid = config.shopperGuid;
+        sharedHeaders.accountid = config.accountId;
+    }
+    ScannerAPI.HEADERS = sharedHeaders;
+    PortalAPI.HEADERS = sharedHeaders;
+    // Shopper credentials are resolved per-call by resolveShopperHeaders()
+    // (see generated shopper services), so no global header is set here —
+    // that's what lets shopperScope: 'per-request' override per call without
+    // a global value silently taking precedence.
+    ShopperAPI.HEADERS = undefined;
     isInitialized = true;
 }
 /**
@@ -54,50 +78,46 @@ export function isReady() {
 export function getConfig() {
     return currentConfig;
 }
+/**
+ * Get the shopperScope the SDK was initialized with ('singleton' if not yet initialized).
+ */
+export function getShopperScope() {
+    return currentShopperScope;
+}
 /**
  * Reset the SDK configuration.
  */
 export function reset() {
     currentConfig = null;
+    currentShopperScope = 'singleton';
     isInitialized = false;
     ShopperAPI.HEADERS = undefined;
     ScannerAPI.HEADERS = undefined;
     PortalAPI.HEADERS = undefined;
 }
 /**
- * Get credentials from config, throwing if not initialized.
- * Used internally by wrapped services.
+ * Resolves the shopperguid/accountid/apikey headers for a single shopper API call.
+ *
+ * Used internally by every generated shopper service method. `context`, when
+ * provided, overrides the shopperGuid/accountId set at DRT.init() — this is
+ * what makes shopperScope: 'per-request' work. apiKey always comes from
+ * DRT.init(), since it identifies the calling backend, not the shopper.
  */
-export function getCredentials() {
+export function resolveShopperHeaders(context) {
+    var _a, _b;
     if (!currentConfig) {
         throw new Error('DRT SDK not initialized. Call DRT.init() first.');
     }
+    const shopperGuid = (_a = context === null || context === void 0 ? void 0 : context.shopperGuid) !== null && _a !== void 0 ? _a : currentConfig.shopperGuid;
+    const accountId = (_b = context === null || context === void 0 ? void 0 : context.accountId) !== null && _b !== void 0 ? _b : currentConfig.accountId;
+    if (!shopperGuid || !accountId) {
+        throw new Error(currentShopperScope === 'per-request'
+            ? 'No shopperGuid/accountId available for this call. DRT SDK was initialized with shopperScope: "per-request" without defaults — pass { shopperGuid, accountId } as the last argument to this call.'
+            : 'DRT SDK not initialized with shopperGuid/accountId. Call DRT.init() first.');
+    }
     return {
-        shopperGuid: currentConfig.shopperGuid,
-        accountId: currentConfig.accountId,
-        apiKey: currentConfig.apiKey,
+        shopperguid: shopperGuid,
+        accountid: accountId,
+        apikey: currentConfig.apiKey,
     };
 }
-/**
- * Creates a proxy that auto-injects credentials for service methods.
- * Methods that take (shopperguid, accountid, apikey, ...rest) as first 3 params
- * will have those auto-filled from the SDK config.
- */
-export function createAutoCredentialsProxy(service) {
-    return new Proxy(service, {
-        get(target, prop) {
-            const value = target[prop];
-            if (typeof value === 'function') {
-                return (...args) => {
-                    // If SDK is initialized, prepend credentials
-                    if (isInitialized && currentConfig) {
-                        return value.call(target, currentConfig.shopperGuid, currentConfig.accountId, currentConfig.apiKey, ...args);
-                    }
-                    // Otherwise call with original args
-                    return value.apply(target, args);
-                };
-            }
-            return value;
-        },
-    });
-}

package/dist/esm/src/generated/portal/core/OpenAPI.js CHANGED Viewed

@@ -1,6 +1,6 @@
 export const OpenAPI = {
     BASE: '',
-    VERSION: '20260623.1',
+    VERSION: '20260629.2',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
     TOKEN: undefined,

package/dist/esm/src/generated/portal/core/request.js CHANGED Viewed

@@ -194,13 +194,16 @@ export const getResponseBody = async (response) => {
             const contentType = response.headers.get("Content-Type");
             if (contentType) {
                 const jsonTypes = ["application/json", "application/problem+json"];
-                const isJSON = jsonTypes.some((type) => contentType.toLowerCase().startsWith(type));
+                const lc = contentType.toLowerCase();
+                const isJSON = jsonTypes.some((type) => lc.startsWith(type));
                 if (isJSON) {
                     return await response.json();
                 }
-                else {
-                    return await response.text();
+                // Return Blob for PDF / binary responses
+                if (lc.startsWith('application/pdf') || lc.startsWith('application/octet-stream')) {
+                    return await response.blob();
                 }
+                return await response.text();
             }
         }
         catch (error) {
@@ -230,7 +233,36 @@ export const catchErrorCodes = (options, result) => {
         throw new ApiError(options, result, `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`);
     }
 };
-let globalCookieHeader;
+// Cookies are cached per request "identity" rather than in one shared slot.
+// Shopper calls carry shopperguid/accountid in options.headers (resolved
+// per-call by resolveShopperHeaders()), so each shopper gets its own cookie
+// jar instead of one shopper's session leaking into another's requests when
+// a single SDK instance serves many shoppers concurrently (shopperScope:
+// 'per-request'). Portal/scanner calls carry no such header and fall back to
+// the single default slot, matching prior behavior.
+const DEFAULT_COOKIE_KEY = "__default__";
+const MAX_COOKIE_ENTRIES = 10000;
+const cookiesByKey = new Map();
+const getCookieKey = (options) => {
+    var _a, _b;
+    const shopperguid = (_a = options.headers) === null || _a === void 0 ? void 0 : _a["shopperguid"];
+    const accountid = (_b = options.headers) === null || _b === void 0 ? void 0 : _b["accountid"];
+    if (isStringWithValue(shopperguid)) {
+        return `${shopperguid}:${isStringWithValue(accountid) ? accountid : ""}`;
+    }
+    return DEFAULT_COOKIE_KEY;
+};
+const storeCookie = (key, value) => {
+    if (!cookiesByKey.has(key) && cookiesByKey.size >= MAX_COOKIE_ENTRIES) {
+        // Evict the oldest entry (Map preserves insertion order) to bound memory
+        // on a long-running, many-shopper backend process.
+        const oldestKey = cookiesByKey.keys().next().value;
+        if (oldestKey !== undefined) {
+            cookiesByKey.delete(oldestKey);
+        }
+    }
+    cookiesByKey.set(key, value);
+};
 /**
  * Wraps sendRequest to capture cookies on login
  * and attach cookies on other requests
@@ -241,6 +273,7 @@ export const request = (config, options) => {
             const url = getUrl(config, options);
             const formData = getFormData(options);
             const body = getRequestBody(options);
+            const cookieKey = getCookieKey(options);
             // Before making headers, possibly attach cookie if we have it
             const baseHeaders = await getHeaders(config, options);
             // We will build combined headers
@@ -248,9 +281,10 @@ export const request = (config, options) => {
             baseHeaders.forEach((value, key) => {
                 headerObj[key] = value;
             });
-            if (globalCookieHeader) {
+            const storedCookie = cookiesByKey.get(cookieKey);
+            if (storedCookie) {
                 // Attach stored cookie
-                headerObj["Cookie"] = globalCookieHeader;
+                headerObj["Cookie"] = storedCookie;
             }
             const headers = new Headers(headerObj);
             if (!onCancel.isCancelled) {
@@ -259,7 +293,7 @@ export const request = (config, options) => {
                 const setCookie = response.headers.get("set-cookie");
                 if (setCookie) {
                     // Overwrite or append as needed
-                    globalCookieHeader = setCookie;
+                    storeCookie(cookieKey, setCookie);
                 }
                 const responseBody = await getResponseBody(response);
                 const responseHeader = getResponseHeader(response, options.responseHeader);

package/dist/esm/src/generated/scanner/core/OpenAPI.js CHANGED Viewed

@@ -1,6 +1,6 @@
 export const OpenAPI = {
     BASE: 'https://api.drttix.com/scanner-v3',
-    VERSION: '20260307.1',
+    VERSION: '20260713.1',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
     TOKEN: undefined,