@contrail/cli 3.5.0 → 3.5.1-alpha.64bf880

package/node_modules/@contrail/loader/lib/pipeline/validate.spec.js

@@ -118,6 +118,59 @@ describe('validate', () => {
         expect(multiSelectIssues).toHaveLength(1);
         expect(multiSelectIssues[0].suggestedFix?.type).toBe(types_3.SuggestedFixType.CHANGE_SEPARATOR);
     });
+    it('should validate Family/Option-suffixed columns against the base option set', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                vfAdvConceptsTech: {
+                    slug: 'vfAdvConceptsTech',
+                    label: 'Advanced Concepts Tech',
+                    propertyType: 'multi_select',
+                    typePropertyOptionSetId: 'os-suffix',
+                    options: [
+                        { value: 'ortholite', display: 'Ortholite' },
+                        { value: 'hoverSpring', display: 'Hover Spring' },
+                    ],
+                    optionLookupByValue: {
+                        ortholite: { value: 'ortholite', display: 'Ortholite' },
+                        hoverSpring: { value: 'hoverSpring', display: 'Hover Spring' },
+                    },
+                    optionLookupByDisplay: {
+                        Ortholite: { value: 'ortholite', display: 'Ortholite' },
+                        'Hover Spring': { value: 'hoverSpring', display: 'Hover Spring' },
+                    },
+                },
+            },
+        });
+        const rows = [
+            { federatedId: '1', name: 'A', vfAdvConceptsTechFamily: 'ortholite,GRIPMAX SLIP RESISTANT,hoverSpring' },
+        ];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        expect(result.valid).toBe(false);
+        const issues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'vfAdvConceptsTechFamily');
+        expect(issues.length).toBeGreaterThan(0);
+        const offending = issues.find((i) => i.message.includes('GRIPMAX SLIP RESISTANT'));
+        expect(offending).toBeDefined();
+    });
+    it('flags missing option set on suffixed columns (no typePropertyOptionSetId)', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                lifecycleStage: {
+                    slug: 'lifecycleStage',
+                    label: 'Lifecycle Stage',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: undefined,
+                    options: [],
+                    optionLookupByValue: {},
+                    optionLookupByDisplay: {},
+                },
+            },
+        });
+        const rows = [{ federatedId: '1', name: 'A', lifecycleStageOption: 'concept' }];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const issues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'lifecycleStageOption');
+        expect(issues.length).toBe(1);
+        expect(issues[0].message).toContain('no option set attached');
+    });
     it('should skip empty values in option set validation', async () => {
         const analysis = makeAnalysis({
             optionSetUsingTypePropertiesBySlug: {
@@ -531,59 +584,6 @@ describe('validate', () => {
             expect(conflict).toBeUndefined();
         });
     });
-    describe('validateAssortmentColumns', () => {
-        it('should skip for non-ASSORTMENT loads', async () => {
-            const config = { loadType: [types_1.LoadType.ITEM] };
-            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
-            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
-            const assortmentIssue = result.issues.find((i) => i.columnName?.includes('assortmentId'));
-            expect(assortmentIssue).toBeUndefined();
-        });
-        it('should error when no rows have assortmentId or assortmentIdentifier', async () => {
-            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
-            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
-            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
-            const issue = result.issues.find((i) => i.message.includes('ASSORTMENT loads require'));
-            expect(issue).toBeDefined();
-            expect(result.valid).toBe(false);
-        });
-        it('should error when rows have both assortmentId and assortmentIdentifier', async () => {
-            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
-            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'id-1', assortmentIdentifier: 'ident-1' }];
-            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
-            const issue = result.issues.find((i) => i.message.includes('both "assortmentId" and "assortmentIdentifier"'));
-            expect(issue).toBeDefined();
-        });
-        it('should error when assortmentId values are empty', async () => {
-            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
-            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: '' }];
-            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
-            const issue = result.issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
-            expect(issue).toBeDefined();
-        });
-        it('should not error when rows have valid assortmentId', async () => {
-            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
-            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' }];
-            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
-            const columnIssue = result.issues.find((i) => i.message.includes('ASSORTMENT loads require'));
-            expect(columnIssue).toBeUndefined();
-        });
-        it('should not error on rows missing assortmentId when derived from conditional columns with conditions', async () => {
-            const config = {
-                loadType: [types_1.LoadType.ASSORTMENT],
-                conditionalColumns: [
-                    { toProperty: 'assortmentId', conditions: [{ conditional: "{gender} === 'mens'", value: 'assort-1' }] },
-                ],
-            };
-            const rows = [
-                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' },
-                { itemFamilyFederatedId: 'fam-2', name: 'B' },
-            ];
-            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
-            const emptyIssue = result.issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
-            expect(emptyIssue).toBeUndefined();
-        });
-    });
     describe('validatePartialAssortmentConfig', () => {
         it('should skip for non-ASSORTMENT loads', async () => {
             const config = { loadType: [types_1.LoadType.ITEM], partialAssortmentUpdate: true };
@@ -1211,4 +1211,108 @@ describe('validate', () => {
             expect(unmappedPropIssues[0].message).toContain('noLabel');
         });
     });
+    describe('object reference resolution validation', () => {
+        const colorConfig = {
+            loadType: [types_1.LoadType.COLOR],
+            federatedMappings: { federatedId: 'federatedId', name: 'name' },
+        };
+        const typesByPathWithVendorRef = {
+            color: {
+                type: { typeProperties: [{ slug: 'vendor', propertyType: 'object_reference' }] },
+                allPropertiesSlugs: ['vendor'],
+                typePropertyToValueType: {},
+                objectReferenceProperties: [
+                    {
+                        slug: 'vendor',
+                        propertyType: 'object_reference',
+                        referencedTypeRootSlug: 'vendor',
+                        referencedTypePath: 'vendor',
+                    },
+                ],
+                userListProperties: [],
+            },
+        };
+        it('should emit one warning per unique missing value with affected rows', async () => {
+            const mockClient = {
+                get: jest.fn().mockResolvedValue([{ federatedId: 'acme', id: 'vendor-acme' }]),
+            };
+            const rows = [
+                { federatedId: 'c-1', name: 'Red', vendor: 'acme' },
+                { federatedId: 'c-2', name: 'Blue', vendor: 'missing-vendor' },
+                { federatedId: 'c-3', name: 'Green', vendor: 'another-missing' },
+                { federatedId: 'c-4', name: 'Yellow', vendor: 'missing-vendor' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithVendorRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis, mockClient);
+            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND &&
+                i.columnName === 'vendor');
+            expect(refIssues).toHaveLength(2);
+            for (const issue of refIssues) {
+                expect(issue.severity).toBe(types_3.PreValidationSeverity.WARNING);
+                expect(issue.propertyType).toBe('object_reference');
+            }
+            const byValue = new Map(refIssues.map((i) => [i.affectedRows[0].value, i]));
+            expect(byValue.get('missing-vendor').affectedRows.map((r) => r.row).sort()).toEqual([3, 5]);
+            expect(byValue.get('missing-vendor').message).toContain('"missing-vendor"');
+            expect(byValue.get('another-missing').affectedRows.map((r) => r.row)).toEqual([4]);
+            expect(byValue.get('another-missing').message).toContain('"another-missing"');
+        });
+        it('should not emit a warning when all references resolve', async () => {
+            const mockClient = {
+                get: jest.fn().mockResolvedValue([
+                    { federatedId: 'acme', id: 'vendor-acme' },
+                    { federatedId: 'foo', id: 'vendor-foo' },
+                ]),
+            };
+            const rows = [
+                { federatedId: 'c-1', name: 'Red', vendor: 'acme' },
+                { federatedId: 'c-2', name: 'Blue', vendor: 'foo' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithVendorRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis, mockClient);
+            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND);
+            expect(refIssues).toHaveLength(0);
+        });
+        it('should skip the lookup entirely when no client is provided', async () => {
+            const rows = [{ federatedId: 'c-1', name: 'Red', vendor: 'missing' }];
+            const analysis = makeAnalysis({}, typesByPathWithVendorRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND);
+            expect(refIssues).toHaveLength(0);
+        });
+        it('should prefix custom-entity referenced fed ids when looking up', async () => {
+            const customEntityTypesByPath = {
+                color: {
+                    type: { typeProperties: [{ slug: 'category', propertyType: 'object_reference' }] },
+                    allPropertiesSlugs: ['category'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        {
+                            slug: 'category',
+                            propertyType: 'object_reference',
+                            referencedTypeRootSlug: 'custom-entity',
+                            referencedTypePath: 'custom-entity:category',
+                        },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const mockClient = {
+                get: jest.fn().mockResolvedValue([
+                    { federatedId: 'custom-entity:category:resolved', id: 'cat-1' },
+                ]),
+            };
+            const rows = [
+                { federatedId: 'c-1', name: 'Red', category: 'resolved' },
+                { federatedId: 'c-2', name: 'Blue', category: 'unresolved' },
+            ];
+            const analysis = makeAnalysis({}, customEntityTypesByPath);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis, mockClient);
+            const refIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.REFERENCE_DATA_NOT_FOUND &&
+                i.columnName === 'category');
+            expect(refIssues).toHaveLength(1);
+            expect(refIssues[0].affectedRows).toHaveLength(1);
+            expect(refIssues[0].affectedRows[0].value).toBe('unresolved');
+        });
+    });
 });

package/node_modules/@contrail/loader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/loader",
-  "version": "2.0.6",
+  "version": "2.0.9",
   "description": "Client library for helping with loader jobs.",
   "homepage": "https://archergreysorg.github.io/contrail-loader/",
   "main": "lib/index.js",
@@ -36,7 +36,8 @@
     "form-data": "^4.0.0",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.0",
-    "p-limit": "^3.0.0"
+    "p-limit": "^3.0.0",
+    "validate-color": "^2.2.4"
   },
   "devDependencies": {
     "@types/jest": "^29.5.2",

package/node_modules/@contrail/sdk/.github/workflows/publish-to-npm.yml

@@ -0,0 +1,120 @@
+name: Publish to NPM
+
+on:
+  push:
+    branches: [master]
+    paths-ignore:
+      - '.github/**'
+  pull_request:
+    paths-ignore:
+      - '.github/**'
+
+jobs:
+  check-version:
+    name: Verify version is available on npm
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check version not already published
+        run: |
+          PACKAGE_NAME=$(node -p "require('./package.json').name")
+          VERSION=$(node -p "require('./package.json').version")
+          echo "Checking if ${PACKAGE_NAME}@${VERSION} exists on npm..."
+          if npm view "${PACKAGE_NAME}@${VERSION}" version 2>/dev/null; then
+            echo "::error::Version ${VERSION} is already published on npm. Bump the version in package.json before merging."
+            exit 1
+          else
+            echo "Version ${VERSION} is available."
+          fi
+
+  check-dependencies:
+    name: Verify no private dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Verify no private dependencies
+        run: |
+          node -e "
+            const deps = require('./package.json').dependencies || {};
+            const { execSync } = require('child_process');
+            let failed = false;
+            for (const pkg of Object.keys(deps)) {
+              try {
+                execSync('npm view ' + pkg, { stdio: 'pipe' });
+              } catch {
+                console.error('::error::Dependency ' + pkg + ' is not publicly accessible on npm');
+                failed = true;
+              }
+            }
+            if (failed) process.exit(1);
+            console.log('All ' + Object.keys(deps).length + ' dependencies are public.');
+          "
+
+  publish-alpha:
+    name: Publish alpha
+    needs: check-dependencies
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.publish.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install and build
+        run: npm ci && npm run build
+
+      - name: Publish alpha
+        id: publish
+        run: |
+          SHORT_SHA=$(echo ${{ github.event.pull_request.head.sha }} | cut -c1-7)
+          VERSION=$(node -p "require('./package.json').version")-alpha.${SHORT_SHA}
+          npm version $VERSION --no-git-tag-version
+          OUTPUT=$(npm publish --tag alpha 2>&1) && {
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+          } || {
+            if echo "$OUTPUT" | grep -q "You cannot publish over the previously published versions"; then
+              echo "::warning::Alpha ${VERSION} already published, skipping."
+            else
+              echo "::error::Failed to publish alpha ${VERSION}"
+              echo "$OUTPUT"
+              exit 1
+            fi
+          }
+
+  publish-release:
+    name: Publish release
+    needs: check-dependencies
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.publish.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install and build
+        run: npm ci && npm run build
+
+      - name: Publish release
+        id: publish
+        run: |
+          npm publish
+          echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT

package/node_modules/@contrail/sdk/lib/auth/login.js

@@ -93,8 +93,16 @@ function usernameAuthentication(email, password, orgSlug) {
             cognitoUser.authenticateUser(authDetails, {
                 onSuccess: (result) => __awaiter(this, void 0, void 0, function* () {
                     const user = result;
-                    const config = yield setAuthContext(user.idToken.jwtToken, orgSlug);
-                    resolve(config);
+                    const cognitoAccessToken = user.idToken.jwtToken;
+                    try {
+                        const apiTokens = yield exchangeCognitoTokensForApiTokens(cognitoAccessToken);
+                        const config = yield setAuthContext(apiTokens.accessToken, orgSlug, apiTokens.refreshToken);
+                        resolve(config);
+                    }
+                    catch (error) {
+                        console.error('Failed to process Cognito token:', error);
+                        reject(error);
+                    }
                 }),
                 onFailure: (err) => {
                     reject(err);
@@ -103,11 +111,42 @@ function usernameAuthentication(email, password, orgSlug) {
         });
     });
 }
-function setAuthContext(bearerToken, orgSlug) {
+function exchangeCognitoTokensForApiTokens(cognitoAccessToken) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiGateway = CONFIGURATION.apiGateway;
+        const url = apiGateway + '/auth/cognito/';
+        const response = yield fetch(url, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                accessToken: cognitoAccessToken,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to authenticate with Cognito token: ${response.status}`);
+        }
+        const data = yield response.json();
+        if (!data.accessToken) {
+            throw new Error('Response from /auth/cognito/ missing required field: accessToken');
+        }
+        if (!data.refreshToken) {
+            throw new Error('Response from /auth/cognito/ missing required field: refreshToken');
+        }
+        return {
+            accessToken: data.accessToken,
+            refreshToken: data.refreshToken,
+        };
+    });
+}
+function setAuthContext(bearerToken, orgSlug, apiRefreshToken) {
     return __awaiter(this, void 0, void 0, function* () {
         let apiGateway = CONFIGURATION.apiGateway;
         auth_1.Auth.config = {
             apiUserToken: bearerToken,
+            apiRefreshToken: apiRefreshToken,
             apiGateway,
             orgSlug,
         };

package/node_modules/@contrail/sdk/lib/core/request.d.ts

@@ -1,9 +1,12 @@
 import { InvocationContext } from '../config/config';
 export declare const AUTH_TOKEN_REQUIRED = "Authentication token must be set to make a contrail call.";
+export declare function _resetTokenRefreshPromise(): void;
 export declare class Request {
     private static MAX_RETRIES;
     private static RETRY_DELAY;
     static request(resource: any, params?: any, ctx?: InvocationContext): Promise<any>;
+    private static requestWithRetries;
+    private static isTokenExpiredError;
     private static delay;
     static logError(error: {}, resource: any, params?: {}): void;
     static sanitizeParametersString(params: any): string;

package/node_modules/@contrail/sdk/lib/core/request.js

@@ -12,19 +12,108 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Request = exports.AUTH_TOKEN_REQUIRED = void 0;
+exports.Request = exports._resetTokenRefreshPromise = exports.AUTH_TOKEN_REQUIRED = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const config_1 = require("../config/config");
+const auth_1 = require("../auth/auth");
 exports.AUTH_TOKEN_REQUIRED = 'Authentication token must be set to make a contrail call.';
 class ApiError extends Error {
-    constructor(message, details) {
+    constructor(message, details, errorCode) {
         super(message);
         this.details = details;
+        this.errorCode = errorCode;
         this.details = details;
+        this.errorCode = errorCode;
     }
 }
+let tokenRefreshPromise = null;
+function performTokenRefresh() {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiRefreshToken = (_a = auth_1.Auth.config) === null || _a === void 0 ? void 0 : _a.apiRefreshToken;
+        const apiGateway = (_b = auth_1.Auth.config) === null || _b === void 0 ? void 0 : _b.apiGateway;
+        if (!apiRefreshToken) {
+            throw new Error('No API refresh token available. Please login again.');
+        }
+        if (!apiGateway) {
+            throw new Error('API Gateway not configured. Ensure the application environment is properly configured.');
+        }
+        const url = apiGateway + '/auth/jwt_refresh/';
+        try {
+            const response = yield (0, node_fetch_1.default)(url, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    refreshToken: apiRefreshToken,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`Token refresh failed with status ${response.status}: ${errorText}`);
+            }
+            const data = yield response.json();
+            if (!data.accessToken) {
+                throw new Error(`Token refresh response did not contain a new access token.`);
+            }
+            auth_1.Auth.config.apiUserToken = data.accessToken;
+            (0, config_1.setConfig)(auth_1.Auth.config);
+            console.log('Access token refreshed successfully');
+            return data.accessToken;
+        }
+        catch (error) {
+            throw new Error(`Token refresh failed: ${(_c = error === null || error === void 0 ? void 0 : error.message) !== null && _c !== void 0 ? _c : String(error)}. Please login again with your credentials.`);
+        }
+    });
+}
+function refreshAccessToken() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (tokenRefreshPromise) {
+            console.log('Token refresh already in progress, waiting for completion...');
+            return tokenRefreshPromise;
+        }
+        tokenRefreshPromise = performTokenRefresh();
+        try {
+            const newToken = yield tokenRefreshPromise;
+            return newToken;
+        }
+        finally {
+            tokenRefreshPromise = null;
+        }
+    });
+}
+function _resetTokenRefreshPromise() {
+    tokenRefreshPromise = null;
+}
+exports._resetTokenRefreshPromise = _resetTokenRefreshPromise;
 class Request {
     static request(resource, params = { method: 'get' }, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
+            try {
+                return yield this.requestWithRetries(resource, params, ctx);
+            }
+            catch (error) {
+                if (this.isTokenExpiredError(error)) {
+                    console.log(`[SDK Request: Token Expired] Attempting to refresh access token...`);
+                    try {
+                        yield refreshAccessToken();
+                        params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
+                        console.log(`[SDK Request: Token Refreshed] Retrying request...`);
+                        return yield this.requestWithRetries(resource, params, ctx);
+                    }
+                    catch (refreshError) {
+                        console.error(`[SDK Request: Token Refresh Failed] ${refreshError === null || refreshError === void 0 ? void 0 : refreshError.message}`, refreshError);
+                        throw new ApiError('Access token refresh failed after TOKEN_EXPIRED error. Unable to proceed with request', refreshError);
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    static requestWithRetries(resource, params, ctx) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const userCtx = ctx || (0, config_1.getGlobalContext)();
@@ -33,7 +122,6 @@ class Request {
             const url = API_GATEWAY + resource;
             const method = (params === null || params === void 0 ? void 0 : params.method) ? params.method.toUpperCase() : 'GET';
             const fullResource = `${method} ${url.split('/')[3]}${resource}`;
-            params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
             let res;
             let attempt = 0;
             while (attempt <= this.MAX_RETRIES) {
@@ -72,11 +160,16 @@ class Request {
                 else {
                     const error = yield res.text();
                     const errorJson = this.tryParseStringIntoObject(error);
+                    const isTokenExpired = errorJson && typeof errorJson === 'object' && errorJson.errorCode === 'TOKEN_EXPIRED';
+                    if (isTokenExpired) {
+                        throw new ApiError('Token expired', errorJson, 'TOKEN_EXPIRED');
+                    }
                     if (errorHandler) {
                         const retryCallback = () => __awaiter(this, void 0, void 0, function* () {
+                            params.headers = Object.assign(Object.assign({}, (params.headers || {})), (yield Request.getHeaders()));
                             return yield (0, node_fetch_1.default)(url, params);
                         });
-                        console.log(`[###### SDK Request: ERROR] code ${error.statusCode} resource: ${fullResource}`);
+                        console.log(`[###### SDK Request: ERROR] code ${res.status} resource: ${fullResource}`);
                         console.log(`[###### SDK Request: ERROR] params ${Request.sanitizeParametersString(params)}`);
                         const request = Object.assign(Object.assign({}, params), { url, method });
                         return yield errorHandler.handle(res, errorJson, retryCallback, request);
@@ -97,6 +190,9 @@ class Request {
             }
         });
     }
+    static isTokenExpiredError(error) {
+        return error instanceof ApiError && error.errorCode === 'TOKEN_EXPIRED';
+    }
     static delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }

package/node_modules/@contrail/sdk/lib/entities/entities.client.js

@@ -131,7 +131,7 @@ class Entities {
                 resource += `skipHydrateRelationships=${options.skipHydrateRelationships}&`;
             }
             if (options.federatedIds) {
-                resource += `ids=${options.federatedIds.map((id) => id.replace(/,/g, '_COMMA_')).join(',')}&`;
+                resource += `ids=${options.federatedIds.map((id) => encodeURIComponent(id.replace(/,/g, '_COMMA_'))).join(',')}&`;
             }
             if (options.criteria) {
                 resource += 'criteria=' + JSURL.stringify(options.criteria);

package/node_modules/@contrail/sdk/lib/entities/entity.resource.registry.js

@@ -55,3 +55,4 @@ EntityResourceRegistry.registerEntityResourceName('open-search', 'open-search');
 EntityResourceRegistry.registerEntityResourceName('project-configurator', 'project-configurator');
 EntityResourceRegistry.registerEntityResourceName('identity', 'identities');
 EntityResourceRegistry.registerEntityResourceName('entity-policy', 'entity-policies');
+EntityResourceRegistry.registerEntityResourceName('measurement-spec-entry', 'measurement-spec-entries');

package/node_modules/@contrail/sdk/lib/files/files.d.ts

@@ -1,9 +1,19 @@
+/// <reference types="node" />
 export declare class Files {
     private ctx;
     constructor(ctx?: any);
     createAndUploadFile(file: File, ownedByReference?: string, ttl?: number): Promise<any>;
-    createAndUploadFileFromBuffer(buffer: any, contentType: string, fileName: string, ownedByReference?: string, ttl?: number): Promise<any>;
-    uploadFile(uploadPost: any, file: File): Promise<void>;
-    uploadFileAsStream(uploadPost: any, buffer: File, options?: any): Promise<unknown>;
+    createAndUploadFileFromBuffer(buffer: Buffer, contentType: string, fileName: string, ownedByReference?: string, ttl?: number): Promise<any>;
+    uploadFile(uploadPost: {
+        url: string;
+        fields: Record<string, string>;
+    }, file: File): Promise<void>;
+    uploadFileAsStream(uploadPost: {
+        url: string;
+        fields: Record<string, string>;
+    }, buffer: Buffer | File, options?: {
+        contentType?: string;
+    }): Promise<void>;
+    private withRetry;
     private appendUploadHeaders;
 }