@contrail/flexplm 1.7.7-alpha.3e12cec → 1.7.7-alpha.522cd89

package/lib/util/flexplm-session-manager.d.ts

@@ -1,40 +0,0 @@
-import { FCConfig } from '../interfaces/interfaces';
-export declare class SessionRejectedError extends Error {
-}
-/** Owns the FlexPLM session cookie cache: options, keying, expiry, in-flight acquisition sharing and Set-Cookie parsing. */
-export declare class FlexPLMSessionManager {
-    private config;
-    constructor(config: FCConfig);
-    get options(): {
-        enabled: boolean;
-        ttlMs: number;
-        cookieName: string;
-        retryStatuses: number[];
-    };
-    /**
-     * Waits until no cold session acquisition is running for this key.
-     * Callers must `await` this only when it returns a promise: awaiting even a resolved promise yields,
-     * and the check-then-register in runColdAcquisition has to stay synchronous to be race free.
-     */
-    waitForInFlightAcquisition(): Promise<void> | undefined;
-    /** Runs a cold acquisition and registers it so concurrent callers wait for it instead of opening their own session. */
-    runColdAcquisition<T>(acquire: () => Promise<T>): Promise<T>;
-    private getSessionKey;
-    getCachedSession(): string | undefined;
-    /**
-     * Compare-and-set: stores `cookie` only if the cache still holds the cookie this request was sent with
-     * (`sentCookie`, undefined for a cold acquisition = nothing cached). A late response must not roll back or
-     * resurrect a session that a concurrent event already replaced or cleared.
-     * @returns true if the cache was updated
-     */
-    storeSession(cookie: string, sentCookie: string | undefined): boolean;
-    clearSession(): void;
-    /** Returns the session cookie value Windchill issued on this response, if any (last one wins). */
-    extractSessionCookie(response: Response): string | undefined;
-    /**
-     * Builds the Cookie header value from the configured static Cookie header and the managed session cookie.
-     * With session reuse enabled only the managed cookie is replaced/removed; every other static cookie pair is kept.
-     * With session reuse disabled the static value is returned unchanged.
-     */
-    buildCookieHeader(staticCookie?: string, sessionCookie?: string): string | undefined;
-}

package/lib/util/flexplm-session-manager.js

@@ -1,192 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlexPLMSessionManager = exports.SessionRejectedError = void 0;
-const crypto_1 = require("crypto");
-// Module-level on purpose: a new FlexPLMConnect (and session manager) is constructed for every event.
-const sessionCache = new Map();
-// Upper bound so users/option combinations that are never requested again cannot accumulate cookies forever.
-const MAX_CACHED_SESSIONS = 100;
-const pruneSessionCache = () => {
-    const now = Date.now();
-    for (const [key, session] of sessionCache) {
-        if (session.expiresAt <= now)
-            sessionCache.delete(key);
-    }
-    // Still full: drop the oldest entries (Map keeps insertion order).
-    while (sessionCache.size >= MAX_CACHED_SESSIONS) {
-        sessionCache.delete(sessionCache.keys().next().value);
-    }
-};
-// In-flight cold session acquisitions per key, so concurrent events share one FlexPLM session instead of each creating their own.
-const inFlightAcquisitions = new Map();
-const SESSION_CACHE_DIGEST_KEY = (0, crypto_1.randomBytes)(32);
-const DEFAULT_SESSION_COOKIE_NAME = 'JSESSIONID';
-const DEFAULT_SESSION_TTL_SECONDS = 900;
-const DEFAULT_RETRY_STATUSES = [401, 403];
-const COOKIE_NAME_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-// Thrown internally when a cached cookie was rejected, so the caller can re-acquire under the lock.
-class SessionRejectedError extends Error {
-}
-exports.SessionRejectedError = SessionRejectedError;
-const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const parseRetryStatuses = (value) => {
-    let list = [];
-    if (Array.isArray(value))
-        list = value;
-    else if (typeof value === 'string')
-        list = value.split(',');
-    else if (value !== undefined && value !== null)
-        list = [value];
-    const statuses = list
-        .map(status => (typeof status === 'string' ? status.trim() : status))
-        .filter(status => status !== '' && status !== null && status !== undefined)
-        .map(Number)
-        // Only client-error statuses can mean "session rejected". 2xx/5xx would resend events the server already processed.
-        .filter(status => Number.isInteger(status) && status >= 400 && status <= 499);
-    return statuses.length ? statuses : DEFAULT_RETRY_STATUSES;
-};
-const parseTtlSeconds = (value) => {
-    const ttl = Number(value);
-    return Number.isFinite(ttl) && ttl > 0 ? ttl : DEFAULT_SESSION_TTL_SECONDS;
-};
-const parseCookieName = (value) => {
-    const name = typeof value === 'string' ? value.trim() : '';
-    return COOKIE_NAME_TOKEN.test(name) ? name : DEFAULT_SESSION_COOKIE_NAME;
-};
-/** Owns the FlexPLM session cookie cache: options, keying, expiry, in-flight acquisition sharing and Set-Cookie parsing. */
-class FlexPLMSessionManager {
-    constructor(config) {
-        this.config = config;
-    }
-    get options() {
-        const sessionReuseConfig = this.config?.flexplmConnect?.sessionReuse ?? {};
-        return {
-            enabled: sessionReuseConfig.enabled === true || String(sessionReuseConfig.enabled).toLowerCase() === 'true',
-            ttlMs: parseTtlSeconds(sessionReuseConfig.ttlSeconds) * 1000,
-            cookieName: parseCookieName(sessionReuseConfig.cookieName),
-            retryStatuses: parseRetryStatuses(sessionReuseConfig.retryStatuses),
-        };
-    }
-    /**
-     * Waits until no cold session acquisition is running for this key.
-     * Callers must `await` this only when it returns a promise: awaiting even a resolved promise yields,
-     * and the check-then-register in runColdAcquisition has to stay synchronous to be race free.
-     */
-    waitForInFlightAcquisition() {
-        const key = this.getSessionKey();
-        if (!inFlightAcquisitions.has(key))
-            return undefined;
-        return (async () => {
-            let pending = inFlightAcquisitions.get(key);
-            while (pending) {
-                await pending.catch(() => undefined);
-                pending = inFlightAcquisitions.get(key);
-            }
-        })();
-    }
-    /** Runs a cold acquisition and registers it so concurrent callers wait for it instead of opening their own session. */
-    async runColdAcquisition(acquire) {
-        const key = this.getSessionKey();
-        const acquisition = acquire();
-        inFlightAcquisitions.set(key, acquisition);
-        try {
-            return await acquisition;
-        }
-        finally {
-            if (inFlightAcquisitions.get(key) === acquisition)
-                inFlightAcquisitions.delete(key);
-        }
-    }
-    getSessionKey() {
-        // Options that change the cached value are part of the key; JSON avoids '|' collisions between fields.
-        const { cookieName, ttlMs } = this.options;
-        const staticHeaders = Object.entries(this.config.flexplmConnect?.staticHeaders ?? {})
-            .map(([name, value]) => [name.toLowerCase(), value])
-            .sort(([nameA, valueA], [nameB, valueB]) => {
-            if (nameA !== nameB)
-                return nameA < nameB ? -1 : 1;
-            return valueA < valueB ? -1 : valueA > valueB ? 1 : 0;
-        });
-        const authenticationAndRoutingDigest = (0, crypto_1.createHmac)('sha256', SESSION_CACHE_DIGEST_KEY)
-            .update(JSON.stringify([this.config.userName(), this.config.password(), staticHeaders]))
-            .digest('hex');
-        return JSON.stringify([
-            this.config.apiHost, this.config.urlContext, this.config.plmEnviornment, cookieName, ttlMs, authenticationAndRoutingDigest,
-        ]);
-    }
-    getCachedSession() {
-        if (!this.options.enabled)
-            return undefined;
-        const key = this.getSessionKey();
-        const cachedSessValue = sessionCache.get(key);
-        if (!cachedSessValue)
-            return undefined;
-        if (cachedSessValue.expiresAt <= Date.now()) {
-            sessionCache.delete(key);
-            return undefined;
-        }
-        return cachedSessValue.cookie;
-    }
-    /**
-     * Compare-and-set: stores `cookie` only if the cache still holds the cookie this request was sent with
-     * (`sentCookie`, undefined for a cold acquisition = nothing cached). A late response must not roll back or
-     * resurrect a session that a concurrent event already replaced or cleared.
-     * @returns true if the cache was updated
-     */
-    storeSession(cookie, sentCookie) {
-        const key = this.getSessionKey();
-        if (sessionCache.get(key)?.cookie !== sentCookie)
-            return false;
-        // sliding expiry: Windchill's session timeout is also sliding
-        // delete first so a refreshed entry moves to the newest position (oldest-first eviction then acts as LRU)
-        sessionCache.delete(key);
-        pruneSessionCache();
-        sessionCache.set(key, { cookie, expiresAt: Date.now() + this.options.ttlMs });
-        return true;
-    }
-    clearSession() {
-        sessionCache.delete(this.getSessionKey());
-    }
-    /** Returns the session cookie value Windchill issued on this response, if any (last one wins). */
-    extractSessionCookie(response) {
-        const respHeader = response?.headers;
-        if (!respHeader)
-            return undefined;
-        let raw = [];
-        if (typeof respHeader.getSetCookie === 'function') {
-            raw = respHeader.getSetCookie();
-        }
-        else if (typeof respHeader.get === 'function' && respHeader.get('set-cookie')) {
-            raw = [respHeader.get('set-cookie')];
-        }
-        const name = this.options.cookieName;
-        const regexFilter = new RegExp('(?:^|[,\\s])' + escapeRegExp(name) + '=([^;,\\s]+)', 'g');
-        let jSession;
-        for (const line of raw) {
-            let cookieNameMatcher = regexFilter.exec(line);
-            while (cookieNameMatcher !== null) {
-                jSession = cookieNameMatcher[1];
-                cookieNameMatcher = regexFilter.exec(line);
-            }
-        }
-        return jSession;
-    }
-    /**
-     * Builds the Cookie header value from the configured static Cookie header and the managed session cookie.
-     * With session reuse enabled only the managed cookie is replaced/removed; every other static cookie pair is kept.
-     * With session reuse disabled the static value is returned unchanged.
-     */
-    buildCookieHeader(staticCookie, sessionCookie) {
-        if (!this.options.enabled)
-            return staticCookie || undefined;
-        const name = this.options.cookieName;
-        const pairs = (staticCookie ?? '')
-            .split(';')
-            .map(pair => pair.trim())
-            .filter(pair => pair && pair.split('=')[0].trim() !== name);
-        if (sessionCookie)
-            pairs.push(`${name}=${sessionCookie}`);
-        return pairs.length ? pairs.join('; ') : undefined;
-    }
-}
-exports.FlexPLMSessionManager = FlexPLMSessionManager;

package/lib/util/flexplm-session-manager.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/util/flexplm-session-manager.spec.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const flexplm_session_manager_1 = require("./flexplm-session-manager");
-let userCounter = 0;
-const newManager = (user = 'mgr-user-' + (++userCounter), staticHeaders) => {
-    const config = {
-        apiHost: 'https://flexplm.example.com',
-        urlContext: '/FlexPLM',
-        vibeEventEndpoint: '/api/events',
-        csrfEndpoint: '/csrf',
-        plmEnviornment: 'test',
-        userName: () => user,
-        password: () => 'pass',
-        itemPreDevelopmentLifecycleStages: [],
-        flexplmConnect: { staticHeaders, sessionReuse: { enabled: true } },
-    };
-    return new flexplm_session_manager_1.FlexPLMSessionManager(config);
-};
-describe('FlexPLMSessionManager.storeSession (compare-and-set)', () => {
-    it('should store a cold acquisition when nothing is cached', () => {
-        const m = newManager();
-        expect(m.storeSession('a', undefined)).toBe(true);
-        expect(m.getCachedSession()).toBe('a');
-    });
-    it('should not let a cold acquisition overwrite an entry that appeared meanwhile', () => {
-        const m = newManager();
-        m.storeSession('a', undefined);
-        expect(m.storeSession('b', undefined)).toBe(false);
-        expect(m.getCachedSession()).toBe('a');
-    });
-    it('should replace or refresh the entry while it still holds the cookie that was sent', () => {
-        const m = newManager();
-        m.storeSession('old', undefined);
-        expect(m.storeSession('new', 'old')).toBe(true);
-        expect(m.getCachedSession()).toBe('new');
-        expect(m.storeSession('new', 'new')).toBe(true); // sliding refresh with the same cookie
-    });
-    it('should ignore a late response that was sent with an older cookie', () => {
-        const m = newManager();
-        m.storeSession('old', undefined);
-        m.storeSession('new', 'old');
-        expect(m.storeSession('old', 'old')).toBe(false);
-        expect(m.getCachedSession()).toBe('new');
-    });
-    it('should not resurrect a session that was cleared meanwhile', () => {
-        const m = newManager();
-        m.storeSession('old', undefined);
-        m.clearSession();
-        expect(m.storeSession('old', 'old')).toBe(false);
-        expect(m.getCachedSession()).toBeUndefined();
-    });
-    it('should isolate cached sessions when static authorization headers differ', () => {
-        const firstManager = newManager('shared-user', { Authorization: 'Basic first', PLM_ENV: 'test' });
-        const secondManager = newManager('shared-user', { Authorization: 'Basic second', PLM_ENV: 'test' });
-        firstManager.storeSession('first-session', undefined);
-        expect(secondManager.getCachedSession()).toBeUndefined();
-    });
-    it('should isolate cached sessions when static routing headers differ', () => {
-        const firstManager = newManager('shared-user', { 'X-Route': 'route-a' });
-        const secondManager = newManager('shared-user', { 'X-Route': 'route-b' });
-        firstManager.storeSession('first-session', undefined);
-        expect(secondManager.getCachedSession()).toBeUndefined();
-    });
-    it('should reuse cached sessions for equivalent static headers regardless of header order or casing', () => {
-        const firstManager = newManager('shared-user', { 'Authorization': 'Basic same', 'X-Route': 'route-a' });
-        const secondManager = newManager('shared-user', { 'x-route': 'route-a', 'authorization': 'Basic same' });
-        firstManager.storeSession('shared-session', undefined);
-        expect(secondManager.getCachedSession()).toBe('shared-session');
-    });
-});