@contrail/flexplm 1.7.7-alpha.e66ae52 → 1.7.7-alpha.eb1d846

package/lib/interfaces/interfaces.d.ts

@@ -6,10 +6,6 @@ export interface FCConfig {
     eventObjectClassParam?: string;
     eventFlexTypePathParam?: string;
     flexplmConnect?: any;
-    'flexplmConnect.sessionReuse.enabled'?: boolean | string;
-    'flexplmConnect.sessionReuse.ttlSeconds'?: number | string;
-    'flexplmConnect.sessionReuse.cookieName'?: string;
-    'flexplmConnect.sessionReuse.retryStatuses'?: number | number[] | string;
     taskId?: string;
     apiHost: string;
     userName(): string;

package/lib/util/flexplm-connect.js

@@ -4,6 +4,19 @@ exports.FlexPLMConnect = void 0;
 const app_framework_1 = require("@contrail/app-framework");
 // Module-level on purpose: a new FlexPLMConnect is constructed for every event. Declaring for Session reusing use case.
 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 DEFAULT_SESSION_COOKIE_NAME = 'JSESSIONID';
@@ -58,28 +71,14 @@ class FlexPLMConnect {
     /////////////////////////////////////////////////////////////////////////////
     ///////// ET-390 - Session reuse: start
     /////////////////////////////////////////////////////////////////////////////
-    /*
-    private get sessionOptions() {
-      const sessReuseBool = this.config?.flexplmConnect?.sessionReuse;
-      console.info('sessReuseBool value is --> ' + sessReuseBool);
-      console.info('enabled value is --> ' + sessReuseBool?.enabled);
-      return {
-        enabled: sessReuseBool?.enabled === true || String(sessReuseBool?.enabled).toLowerCase() === 'true',
-        ttlMs: (sessReuseBool?.ttlSeconds ?? 900) * 1000,
-        cookieName: sessReuseBool?.cookieName ?? 'JSESSIONID',
-        retryStatuses: (sessReuseBool?.retryStatuses ?? [401, 403]) as number[],
-      };
-    }
-     */
     get sessionOptions() {
-        const cfg = this.config ?? {};
-        const sessReuseEntries = (name) => cfg[`flexplmConnect.sessionReuse.${name}`];
-        const enabled = sessReuseEntries('enabled');
+        const sessReuse = this.config?.flexplmConnect?.sessionReuse;
+        const enabled = sessReuse?.enabled;
         return {
             enabled: enabled === true || String(enabled).toLowerCase() === 'true',
-            ttlMs: parseTtlSeconds(sessReuseEntries('ttlSeconds')) * 1000,
-            cookieName: parseCookieName(sessReuseEntries('cookieName')),
-            retryStatuses: parseRetryStatuses(sessReuseEntries('retryStatuses')),
+            ttlMs: parseTtlSeconds(sessReuse?.ttlSeconds) * 1000,
+            cookieName: parseCookieName(sessReuse?.cookieName),
+            retryStatuses: parseRetryStatuses(sessReuse?.retryStatuses),
         };
     }
     /**
@@ -144,7 +143,11 @@ class FlexPLMConnect {
     }
     storeSession(cookie) {
         // sliding expiry: Windchill's session timeout is also sliding
-        sessionCache.set(this.getSessionKey(), { cookie, expiresAt: Date.now() + this.sessionOptions.ttlMs });
+        const key = this.getSessionKey();
+        // 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.sessionOptions.ttlMs });
     }
     clearSession() {
         sessionCache.delete(this.getSessionKey());
@@ -226,7 +229,7 @@ class FlexPLMConnect {
             await wait;
         if (getNewSession) {
             const current = this.getCachedSession();
-            if (!current || current === rejectedCookie)
+            if (rejectedCookie === undefined || !current || current === rejectedCookie)
                 this.clearSession();
         }
         const cached = this.getCachedSession();

package/lib/util/flexplm-connect.spec.js

@@ -39,12 +39,8 @@ const resp = (status, setCookie = [], json = csrfBody) => ({
 });
 let userCounter = 0;
 const uniqueUser = () => 'sess-user-' + (++userCounter);
-// The connector config is flat: keys look like 'flexplmConnect.sessionReuse.enabled'
-const sessionConfig = (user, sessionReuse = { enabled: true }) => {
-    const flat = {};
-    Object.entries(sessionReuse).forEach(([k, v]) => { flat[`flexplmConnect.sessionReuse.${k}`] = v; });
-    return createConfig({ userName: () => user, ...flat });
-};
+// The connector config nests the entries: { flexplmConnect: { sessionReuse: { enabled: true, ... } } }
+const sessionConfig = (user, sessionReuse = { enabled: true }) => createConfig({ userName: () => user, flexplmConnect: { sessionReuse } });
 const fetchMock = () => global.fetch;
 const callHeaders = (i) => fetchMock().mock.calls[i][1].headers;
 const callMethod = (i) => fetchMock().mock.calls[i][1].method;
@@ -156,7 +152,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(callHeaders(1).Cookie).toBe('JSESSIONID=abc.tomcat1');
         expect(callHeaders(1).CSRF_NONCE).toBe('n1');
     });
-    it('reuses the cached session on the next event (new FlexPLMConnect instance)', async () => {
+    it('should reuse the cached session on the next event (new FlexPLMConnect instance)', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1; Path=/'])) // event 1 GET
@@ -168,7 +164,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1'); // GET reuses it
         expect(callHeaders(3).Cookie).toBe('JSESSIONID=abc.tomcat1'); // POST reuses it
     });
-    it('replaces the cached session when Windchill answers the GET with a new Set-Cookie', async () => {
+    it('should replace the cached session when Windchill answers the GET with a new Set-Cookie', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1; Path=/']))
@@ -185,7 +181,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(callHeaders(3).Cookie).toBe('JSESSIONID=new.tomcat1'); // POST uses the replacement
         expect(callHeaders(4).Cookie).toBe('JSESSIONID=new.tomcat1'); // event 3 GET sends the replacement
     });
-    it('retries once with a new session when the POST is rejected with 403', async () => {
+    it('should retry once with a new session when the POST is rejected with 403', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1; Path=/'])) // GET
@@ -199,7 +195,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(result.status).toBe(200);
         expect(result.data).toEqual({ ok: true });
     });
-    it('also retries on 401', async () => {
+    it('should also retry on 401', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
@@ -209,7 +205,7 @@ describe('FlexPLMConnect session reuse', () => {
         await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
         expect(fetchMock()).toHaveBeenCalledTimes(4);
     });
-    it('does not loop: a second 403 after the retry is surfaced as an error', async () => {
+    it('should not loop: a second 403 after the retry is surfaced as an error', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
@@ -220,7 +216,7 @@ describe('FlexPLMConnect session reuse', () => {
             .rejects.toThrow('Error sending data to FlexPLM:status: 403');
         expect(fetchMock()).toHaveBeenCalledTimes(4);
     });
-    it('does not retry on non-auth errors such as 500 (event may already be processed)', async () => {
+    it('should not retry on non-auth errors such as 500 (event may already be processed)', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
@@ -229,7 +225,7 @@ describe('FlexPLMConnect session reuse', () => {
             .rejects.toThrow('Error sending data to FlexPLM:status: 500');
         expect(fetchMock()).toHaveBeenCalledTimes(2);
     });
-    it('retries the csrf GET without a cookie when the cached session is rejected there', async () => {
+    it('should retry the csrf GET without a cookie when the cached session is rejected there', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1'])) // event 1 GET
@@ -243,7 +239,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(callHeaders(3).Cookie).toBeUndefined();
         expect(callHeaders(4).Cookie).toBe('JSESSIONID=new.tomcat1');
     });
-    it('expires the cached session after ttlSeconds', async () => {
+    it('should expire the cached session after ttlSeconds', async () => {
         const u = uniqueUser();
         const realNow = Date.now();
         const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
@@ -260,7 +256,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(callHeaders(3).Cookie).toBe('JSESSIONID=def.tomcat1');
         nowSpy.mockRestore();
     });
-    it('uses the last JSESSIONID when several Set-Cookie lines are returned', async () => {
+    it('should use the last JSESSIONID when several Set-Cookie lines are returned', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=first.tomcat1; Path=/', 'OTHER=x; Path=/', 'JSESSIONID=second.tomcat1; Path=/']))
@@ -268,7 +264,7 @@ describe('FlexPLMConnect session reuse', () => {
         await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
         expect(callHeaders(1).Cookie).toBe('JSESSIONID=second.tomcat1');
     });
-    it('falls back to headers.get("set-cookie") when getSetCookie is not available', async () => {
+    it('should fall back to headers.get("set-cookie") when getSetCookie is not available', async () => {
         const u = uniqueUser();
         const legacy = {
             status: 200,
@@ -280,7 +276,7 @@ describe('FlexPLMConnect session reuse', () => {
         await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
         expect(callHeaders(1).Cookie).toBe('JSESSIONID=legacy.tomcat1');
     });
-    it('honours a custom cookieName', async () => {
+    it('should honour a custom cookieName', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['MYSESSION=zzz; Path=/', 'JSESSIONID=ignored; Path=/']))
@@ -288,7 +284,7 @@ describe('FlexPLMConnect session reuse', () => {
         await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'MYSESSION' })).sendToFlexPLM(payload);
         expect(callHeaders(1).Cookie).toBe('MYSESSION=zzz');
     });
-    it('accepts enabled as the string "true"', async () => {
+    it('should accept enabled as the string "true"', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
@@ -296,7 +292,39 @@ describe('FlexPLMConnect session reuse', () => {
         await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: 'true' })).sendToFlexPLM(payload);
         expect(callHeaders(1).Cookie).toBe('JSESSIONID=abc.tomcat1');
     });
-    it('keeps separate sessions per user', async () => {
+    it('should evict expired sessions of other users when a new session is stored', async () => {
+        const userA = uniqueUser();
+        const userB = uniqueUser();
+        const realNow = Date.now();
+        const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
+        fetchMock()
+            .mockResolvedValueOnce(resp(200, ['JSESSIONID=a.tomcat1'])) // A GET
+            .mockResolvedValueOnce(resp(200, [], {})) // A POST
+            .mockResolvedValueOnce(resp(200, ['JSESSIONID=b.tomcat1'])) // B GET
+            .mockResolvedValueOnce(resp(200, [], {})) // B POST
+            .mockResolvedValueOnce(resp(200, ['JSESSIONID=a2.tomcat1'])) // A GET again
+            .mockResolvedValueOnce(resp(200, [], {}));
+        const cfg = (u) => sessionConfig(u, { enabled: true, ttlSeconds: 1 });
+        await new flexplm_connect_1.FlexPLMConnect(cfg(userA)).sendToFlexPLM(payload);
+        nowSpy.mockReturnValue(realNow + 2000); // A has expired
+        await new flexplm_connect_1.FlexPLMConnect(cfg(userB)).sendToFlexPLM(payload); // storing B sweeps A
+        nowSpy.mockReturnValue(realNow); // rewind: only a swept A has no entry left
+        await new flexplm_connect_1.FlexPLMConnect(cfg(userA)).sendToFlexPLM(payload);
+        expect(callHeaders(4).Cookie).toBeUndefined();
+        nowSpy.mockRestore();
+    });
+    it('should not hold more than the maximum number of cached sessions', async () => {
+        const first = uniqueUser();
+        fetchMock().mockImplementation(async () => resp(200, ['JSESSIONID=s.tomcat1']));
+        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(first)).sendToFlexPLM(payload);
+        for (let i = 0; i < 100; i++) {
+            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(uniqueUser())).sendToFlexPLM(payload);
+        }
+        fetchMock().mockClear();
+        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(first)).sendToFlexPLM(payload);
+        expect(callHeaders(0).Cookie).toBeUndefined(); // oldest entry was evicted
+    });
+    it('should keep separate sessions per user', async () => {
         const a = uniqueUser();
         const b = uniqueUser();
         fetchMock()
@@ -309,7 +337,7 @@ describe('FlexPLMConnect session reuse', () => {
         expect(callHeaders(2).Cookie).toBeUndefined(); // user b must not see user a's cookie
         expect(callHeaders(3).Cookie).toBe('JSESSIONID=bbb.tomcat1');
     });
-    it('never logs the cookie value', async () => {
+    it('should never log the cookie value', async () => {
         const isInfoOn = jest.spyOn(app_framework_1.Logger, 'isInfoOn').mockReturnValue(true);
         const info = jest.spyOn(console, 'info').mockImplementation();
         const u = uniqueUser();
@@ -340,11 +368,11 @@ describe('FlexPLMConnect session reuse', () => {
             ['a comma separated string', '401, 403'],
             ['garbage (falls back to 401/403)', 'abc'],
             ['an empty array (falls back to 401/403)', []],
-        ])('retryStatuses given as %s does not throw and still retries on 403', async (_label, retryStatuses) => {
+        ])('should not throw and still retry on 403 when retryStatuses is %s', async (_label, retryStatuses) => {
             await rejectedOnceThenOk(uniqueUser(), { retryStatuses });
             expect(fetchMock()).toHaveBeenCalledTimes(4);
         });
-        it.each([['abc'], [0], [-5]])('invalid ttlSeconds (%p) falls back to the 900s default', async (ttlSeconds) => {
+        it.each([['abc'], [0], [-5]])('should fall back to the 900s default when ttlSeconds is invalid (%p)', async (ttlSeconds) => {
             const u = uniqueUser();
             const realNow = Date.now();
             const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
@@ -360,7 +388,7 @@ describe('FlexPLMConnect session reuse', () => {
             expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
             nowSpy.mockRestore();
         });
-        it('a blank cookieName falls back to JSESSIONID', async () => {
+        it('should fall back to JSESSIONID when cookieName is blank', async () => {
             const u = uniqueUser();
             fetchMock()
                 .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
@@ -473,7 +501,7 @@ describe('FlexPLMConnect session reuse', () => {
         });
     });
     describe('cookie names containing regex metacharacters', () => {
-        it('extracts a cookie whose name contains "+"', async () => {
+        it('should extract a cookie whose name contains "+"', async () => {
             const u = uniqueUser();
             fetchMock()
                 .mockResolvedValueOnce(resp(200, ['SID+=abc; Path=/']))
@@ -481,7 +509,7 @@ describe('FlexPLMConnect session reuse', () => {
             await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'SID+' })).sendToFlexPLM(payload);
             expect(callHeaders(1).Cookie).toBe('SID+=abc');
         });
-        it('treats "." literally and does not match a look-alike cookie', async () => {
+        it('should treat "." literally and not match a look-alike cookie', async () => {
             const u = uniqueUser();
             fetchMock()
                 .mockResolvedValueOnce(resp(200, ['AxB=wrong; Path=/']))
@@ -493,7 +521,7 @@ describe('FlexPLMConnect session reuse', () => {
     describe('concurrent session acquisition', () => {
         const flush = () => new Promise(r => setImmediate(r));
         const isColdGet = (call) => call[1].method === 'GET' && !call[1].headers.Cookie;
-        it('shares one session across concurrent events on a cold cache', async () => {
+        it('should share one session across concurrent events on a cold cache', async () => {
             const u = uniqueUser();
             let release;
             const gate = new Promise(r => { release = r; });
@@ -512,7 +540,7 @@ describe('FlexPLMConnect session reuse', () => {
             expect(fetchMock().mock.calls.filter(isColdGet)).toHaveLength(1);
             results.forEach(r => expect(r.sessionCookie).toBe('abc.tomcat1'));
         });
-        it('a waiter does not inherit the failure of the first acquisition', async () => {
+        it('should not make a waiter inherit the failure of the first acquisition', async () => {
             const u = uniqueUser();
             let release;
             const gate = new Promise(r => { release = r; });
@@ -527,7 +555,7 @@ describe('FlexPLMConnect session reuse', () => {
             expect(await firstResult).toBeInstanceOf(Error);
             expect((await second).sessionCookie).toBe('abc.tomcat1');
         });
-        it('parallel events rejected with 403 create only one replacement session', async () => {
+        it('should create only one replacement session for parallel events rejected with 403', async () => {
             const u = uniqueUser();
             fetchMock().mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']));
             await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF(); // prime the cache with the old session
@@ -547,7 +575,7 @@ describe('FlexPLMConnect session reuse', () => {
 });
 describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
     const payload = { id: '123' };
-    it('sends no Cookie header and makes exactly one GET + one POST', async () => {
+    it('should send no Cookie header and make exactly one GET + one POST', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1'])) // Set-Cookie present but must be ignored
@@ -561,7 +589,7 @@ describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
             expect(callHeaders(i).Cookie).toBeUndefined();
         }
     });
-    it('does not retry on 403 (behaves exactly as before)', async () => {
+    it('should not retry on 403 (behaves exactly as before)', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200))
@@ -570,7 +598,7 @@ describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
             .rejects.toThrow('Error sending data to FlexPLM:status: 403');
         expect(fetchMock()).toHaveBeenCalledTimes(2);
     });
-    it('explicit enabled:false behaves the same as not configured', async () => {
+    it('should behave the same as not configured when enabled is false', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
@@ -578,9 +606,18 @@ describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
         await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: false })).sendToFlexPLM(payload);
         expect(callHeaders(1).Cookie).toBeUndefined();
     });
+    it('should ignore the legacy flat key form', async () => {
+        const u = uniqueUser();
+        fetchMock()
+            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1'])) // Set-Cookie present but must be ignored
+            .mockResolvedValueOnce(resp(200, [], {}));
+        const cfg = createConfig({ userName: () => u, 'flexplmConnect.sessionReuse.enabled': true });
+        await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
+        expect(callHeaders(1).Cookie).toBeUndefined();
+    });
 });
 describe('FlexPLMConnect.getRequest session reuse', () => {
-    it('sends the cached cookie on image/GET requests', async () => {
+    it('should send the cached cookie on image/GET requests', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1'])) // csrf GET primes the cache
@@ -591,7 +628,7 @@ describe('FlexPLMConnect.getRequest session reuse', () => {
         await connect.getRequest();
         expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
     });
-    it('retries once without the cookie when the cached session is rejected on getRequest', async () => {
+    it('should retry once without the cookie when the cached session is rejected on getRequest', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
@@ -604,7 +641,7 @@ describe('FlexPLMConnect.getRequest session reuse', () => {
         expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
         expect(callHeaders(3).Cookie).toBeUndefined();
     });
-    it('does not re-store the rejected cookie when the retry issues no Set-Cookie', async () => {
+    it('should not re-store the rejected cookie when the retry issues no Set-Cookie', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=stale.tomcat1']))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.7.7-alpha.e66ae52",
+  "version": "1.7.7-alpha.eb1d846",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",