@emilgroup/migration-sdk 0.10.1-beta.13 → 0.10.1-beta.17

package/dist/base.d.ts

@@ -22,9 +22,19 @@ export declare const COLLECTION_FORMATS: {
     tsv: string;
     pipes: string;
 };
+export interface SessionClass {
+    sub: string;
+    username?: string;
+    email?: string;
+    tenantSlug?: string;
+    permissions?: string;
+    expiresAt?: number;
+}
 export interface LoginClass {
     accessToken: string;
     permissions: string;
+    authMode?: string;
+    session?: SessionClass;
 }
 export declare enum Environment {
     Production = "https://apiv2.emil.de",
@@ -55,7 +65,18 @@ export declare class BaseAPI {
     protected configuration: Configuration | undefined;
     private tokenData?;
     constructor(configuration?: Configuration, basePath?: string, axios?: AxiosInstance);
-    private useCookieAuth;
+    private sessionAccount;
+    private authBasePath;
+    private usesSession;
+    private useSessionAuth;
+    private useHeaderAuth;
+    private applyTokenReply;
+    private sessionHeaders;
+    private withCurrentAuth;
+    private canRetryWithToken;
+    private canResend;
+    private switchToToken;
+    private retryWithToken;
     selectEnvironment(env: Environment): void;
     selectBasePath(path: string): void;
     getPermissions(): Array<string>;

package/dist/base.js

@@ -74,6 +74,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -112,6 +123,12 @@ function resetRetry() {
 exports.resetRetry = resetRetry;
 var NETWORK_ERROR_MESSAGE = "Network Error";
 var TOKEN_DATA = 'APP_TOKEN';
+// Sent only to authservice, to ask for a server session.
+var AUTH_MODE_HEADER = 'X-Emil-Auth-Mode';
+// Names the account on every call; one browser session can hold several.
+var ACCOUNT_HEADER = 'X-Emil-Account';
+var SESSION_MODES = ['both', 'session'];
+var RESEND_SAFE_METHODS = ['get', 'head', 'options'];
 /**
  *
  * @export
@@ -129,7 +146,10 @@ var BaseAPI = /** @class */ (function () {
             this.configuration = configuration;
             this.basePath = configuration.basePath || this.basePath;
             if (configuration.cookieAuth) {
-                this.useCookieAuth();
+                this.configuration.username = this.configuration.username || this.tokenData.username;
+            }
+            if (this.usesSession()) {
+                this.useSessionAuth();
             }
             else {
                 // Use config token if provided, otherwise use tokenData token
@@ -148,10 +168,94 @@ var BaseAPI = /** @class */ (function () {
         }
         this.attachInterceptor(axios);
     }
-    // Cookie mode: the browser sends the HttpOnly access cookie, so no token is read from storage.
-    BaseAPI.prototype.useCookieAuth = function () {
-        this.configuration.username = this.configuration.username || this.tokenData.username;
-        this.configuration.baseOptions = __assign(__assign({}, this.configuration.baseOptions), { withCredentials: true });
+    // The app's own account wins over APP_TOKEN, which holds whichever tab wrote last.
+    BaseAPI.prototype.sessionAccount = function () {
+        return this.configuration.account || this.tokenData.sub;
+    };
+    // Apps may pass the address as the second argument only; authservice is on the same host.
+    BaseAPI.prototype.authBasePath = function () {
+        return this.configuration.basePath || this.basePath;
+    };
+    BaseAPI.prototype.usesSession = function () {
+        return !!this.configuration.cookieAuth && SESSION_MODES.indexOf(this.tokenData.authMode) !== -1 && !!this.sessionAccount();
+    };
+    BaseAPI.prototype.useSessionAuth = function () {
+        var _a;
+        var _b = this.configuration.baseOptions || {}, headers = _b.headers, baseOptions = __rest(_b, ["headers"]);
+        this.configuration.accessToken = '';
+        this.configuration.baseOptions = __assign(__assign({}, baseOptions), { withCredentials: true, headers: __assign(__assign({}, headers), (_a = {}, _a[ACCOUNT_HEADER] = this.sessionAccount(), _a)) });
+    };
+    BaseAPI.prototype.useHeaderAuth = function (accessToken) {
+        this.configuration.accessToken = accessToken ? "Bearer ".concat(accessToken) : '';
+        this.tokenData.accessToken = accessToken;
+        delete this.tokenData.authMode;
+        delete this.tokenData.sub;
+        if (this.configuration.cookieAuth) {
+            var _a = this.configuration.baseOptions || {}, withCredentials = _a.withCredentials, headers = _a.headers, baseOptions = __rest(_a, ["withCredentials", "headers"]);
+            var _b = headers || {}, _c = ACCOUNT_HEADER, account = _b[_c], otherHeaders = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
+            this.configuration.baseOptions = __assign(__assign({}, baseOptions), { headers: otherHeaders });
+        }
+    };
+    BaseAPI.prototype.applyTokenReply = function (_a) {
+        var accessToken = _a.accessToken, authMode = _a.authMode, session = _a.session;
+        if (this.configuration.cookieAuth && SESSION_MODES.indexOf(authMode) !== -1 && (session === null || session === void 0 ? void 0 : session.sub)) {
+            this.tokenData.authMode = authMode;
+            this.tokenData.sub = session.sub;
+            if (this.configuration.account) {
+                // A workspace switch moves the app to another account.
+                this.configuration.account = session.sub;
+            }
+            // Both keeps the token for apps not moved yet; session mode keeps no token at all.
+            if (authMode === 'both' && accessToken) {
+                this.tokenData.accessToken = accessToken;
+            }
+            else {
+                delete this.tokenData.accessToken;
+            }
+            this.useSessionAuth();
+        }
+        else {
+            this.useHeaderAuth(accessToken);
+        }
+    };
+    BaseAPI.prototype.sessionHeaders = function () {
+        var _a, _b;
+        if (!this.configuration.cookieAuth) {
+            return {};
+        }
+        return __assign((_a = {}, _a[AUTH_MODE_HEADER] = 'session', _a), (this.usesSession() && (_b = {}, _b[ACCOUNT_HEADER] = this.sessionAccount(), _b)));
+    };
+    BaseAPI.prototype.withCurrentAuth = function (config) {
+        delete config.headers['Authorization'];
+        delete config.headers[ACCOUNT_HEADER];
+        if (this.usesSession()) {
+            config.headers[ACCOUNT_HEADER] = this.sessionAccount();
+            config.withCredentials = true;
+        }
+        else if (this.configuration.accessToken) {
+            config.headers['Authorization'] = this.configuration.accessToken;
+        }
+        return config;
+    };
+    // Both keeps the token, so a session call the browser could not complete can be sent again with it.
+    BaseAPI.prototype.canRetryWithToken = function (config) {
+        var _a;
+        return !!config.withCredentials && !!((_a = config.headers) === null || _a === void 0 ? void 0 : _a[ACCOUNT_HEADER])
+            && !!this.tokenData.accessToken && this.tokenData.authMode !== 'session';
+    };
+    // A network error can come after the server ran the call, so only a call that is safe to repeat is sent again.
+    BaseAPI.prototype.canResend = function (config) {
+        return RESEND_SAFE_METHODS.indexOf((config.method || 'get').toLowerCase()) !== -1
+            || Object.keys(config.headers || {}).some(function (name) { return name.toLowerCase() === 'idempotency-key'; });
+    };
+    BaseAPI.prototype.switchToToken = function () {
+        this.useHeaderAuth(this.tokenData.accessToken);
+        this.storeTokenData(this.tokenData);
+    };
+    BaseAPI.prototype.retryWithToken = function (axios, config) {
+        this.switchToToken();
+        config.withCredentials = false;
+        return axios(this.withCurrentAuth(config));
     };
     BaseAPI.prototype.selectEnvironment = function (env) {
         this.selectBasePath(env);
@@ -168,14 +272,15 @@ var BaseAPI = /** @class */ (function () {
     };
     BaseAPI.prototype.authorize = function (username, password, targetWorkspace) {
         return __awaiter(this, void 0, void 0, function () {
-            var options, response, _a, accessToken, permissions;
+            var options, response;
+            var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         options = {
                             method: 'POST',
-                            url: "".concat(this.configuration.basePath, "/authservice/v1/login"),
-                            headers: { 'Content-Type': 'application/json' },
+                            url: "".concat(this.authBasePath(), "/authservice/v1/login"),
+                            headers: __assign({ 'Content-Type': 'application/json' }, (this.configuration.cookieAuth && (_a = {}, _a[AUTH_MODE_HEADER] = 'session', _a))),
                             data: {
                                 username: username,
                                 password: password,
@@ -185,14 +290,10 @@ var BaseAPI = /** @class */ (function () {
                         return [4 /*yield*/, axios_1.default.request(options)];
                     case 1:
                         response = _b.sent();
-                        _a = response.data, accessToken = _a.accessToken, permissions = _a.permissions;
                         this.configuration.username = username;
                         this.tokenData.username = username;
-                        this.tokenData.permissions = permissions;
-                        if (!this.configuration.cookieAuth) {
-                            this.configuration.accessToken = "Bearer ".concat(accessToken);
-                            this.tokenData.accessToken = accessToken;
-                        }
+                        this.tokenData.permissions = response.data.permissions;
+                        this.applyTokenReply(response.data);
                         return [2 /*return*/];
                 }
             });
@@ -218,10 +319,8 @@ var BaseAPI = /** @class */ (function () {
                         });
                         options = {
                             method: 'POST',
-                            url: "".concat(this.configuration.basePath, "/authservice/v1/refresh-token"),
-                            headers: {
-                                'Content-Type': 'application/json',
-                            },
+                            url: "".concat(this.authBasePath(), "/authservice/v1/refresh-token"),
+                            headers: __assign({ 'Content-Type': 'application/json' }, this.sessionHeaders()),
                             data: { username: username },
                             withCredentials: true,
                         };
@@ -234,13 +333,7 @@ var BaseAPI = /** @class */ (function () {
         });
     };
     BaseAPI.prototype.storeTokenData = function (tokenData) {
-        var _a;
         if (typeof window !== 'undefined') {
-            if (tokenData && ((_a = this.configuration) === null || _a === void 0 ? void 0 : _a.cookieAuth)) {
-                // Cookie mode saves who is logged in, never the token; a token saved by apps not yet migrated stays.
-                var username = tokenData.username, permissions = tokenData.permissions;
-                tokenData = __assign(__assign({}, ((0, common_1.defaultStorage)().get(TOKEN_DATA) || {})), { username: username, permissions: permissions });
-            }
             (0, common_1.defaultStorage)().set(TOKEN_DATA, tokenData);
         }
     };
@@ -260,65 +353,75 @@ var BaseAPI = /** @class */ (function () {
         axios.interceptors.response.use(function (res) {
             return res;
         }, function (err) { return __awaiter(_this, void 0, void 0, function () {
-            var originalConfig, _a, tokenString, permissions, accessToken, _error_1, _b, tokenString, permissions, accessToken, _error_2;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var originalConfig, reply, _error_1, reply, _error_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         originalConfig = err.config;
                         if (!(err.response && !(err.response instanceof XMLHttpRequest))) return [3 /*break*/, 5];
                         if (!((err.response.status === 401 || err.response.status === 403)
                             && !originalConfig._retry)) return [3 /*break*/, 4];
                         originalConfig._retry = true;
-                        _c.label = 1;
+                        _a.label = 1;
                     case 1:
-                        _c.trys.push([1, 3, , 4]);
+                        _a.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, this.refreshTokenInternal()];
                     case 2:
-                        _a = _c.sent(), tokenString = _a.accessToken, permissions = _a.permissions;
-                        this.tokenData.permissions = permissions;
-                        delete originalConfig.headers['Authorization'];
-                        // In cookie mode the refresh reply renewed the access cookie, so retry without a header.
-                        if (!this.configuration.cookieAuth) {
-                            accessToken = "Bearer ".concat(tokenString);
-                            originalConfig.headers['Authorization'] = accessToken;
-                            this.configuration.accessToken = accessToken;
-                            this.tokenData.accessToken = tokenString;
-                        }
+                        reply = _a.sent();
+                        this.tokenData.permissions = reply.permissions;
+                        this.applyTokenReply(reply);
                         this.storeTokenData(this.tokenData);
-                        return [2 /*return*/, axios(originalConfig)];
+                        if (!this.usesSession()) {
+                            return [2 /*return*/, axios(this.withCurrentAuth(originalConfig))];
+                        }
+                        // Both mode: if the browser does not send the session cookie (another site), use the token.
+                        return [2 /*return*/, axios(this.withCurrentAuth(originalConfig)).catch(function (retryError) {
+                                var _a;
+                                if (((_a = retryError === null || retryError === void 0 ? void 0 : retryError.response) === null || _a === void 0 ? void 0 : _a.status) !== 401 || !_this.tokenData.accessToken) {
+                                    return Promise.reject(retryError);
+                                }
+                                return _this.retryWithToken(axios, originalConfig);
+                            })];
                     case 3:
-                        _error_1 = _c.sent();
+                        _error_1 = _a.sent();
                         if (_error_1.response && _error_1.response.data) {
                             return [2 /*return*/, Promise.reject(_error_1.response.data)];
                         }
                         return [2 /*return*/, Promise.reject(_error_1)];
-                    case 4: return [3 /*break*/, 9];
+                    case 4: return [3 /*break*/, 10];
                     case 5:
+                        if (!(err.message === NETWORK_ERROR_MESSAGE && this.canRetryWithToken(originalConfig))) return [3 /*break*/, 6];
+                        // Both mode: the browser blocked the session call or hid its reply; later calls use the token.
+                        if (!this.canResend(originalConfig)) {
+                            this.switchToToken();
+                            return [2 /*return*/, Promise.reject(err)];
+                        }
+                        return [2 /*return*/, this.retryWithToken(axios, originalConfig)];
+                    case 6:
                         if (!(err.message === NETWORK_ERROR_MESSAGE
-                            && originalConfig.headers.hasOwnProperty('Authorization')
-                            && _retry_count < 4)) return [3 /*break*/, 9];
+                            && (originalConfig.headers.hasOwnProperty('Authorization')
+                                || (this.configuration.cookieAuth && originalConfig.withCredentials && this.canResend(originalConfig)))
+                            && _retry_count < 4)) return [3 /*break*/, 10];
                         _retry_count++;
-                        _c.label = 6;
-                    case 6:
-                        _c.trys.push([6, 8, , 9]);
-                        return [4 /*yield*/, this.refreshTokenInternal()];
+                        _a.label = 7;
                     case 7:
-                        _b = _c.sent(), tokenString = _b.accessToken, permissions = _b.permissions;
-                        accessToken = "Bearer ".concat(tokenString);
-                        this.tokenData.permissions = permissions;
+                        _a.trys.push([7, 9, , 10]);
+                        return [4 /*yield*/, this.refreshTokenInternal()];
+                    case 8:
+                        reply = _a.sent();
+                        this.tokenData.permissions = reply.permissions;
                         _retry = true;
-                        originalConfig.headers['Authorization'] = accessToken;
-                        this.configuration.accessToken = accessToken;
-                        this.tokenData.accessToken = tokenString;
+                        this.applyTokenReply(reply);
                         this.storeTokenData(this.tokenData);
-                        return [2 /*return*/, axios.request(__assign({}, originalConfig))];
-                    case 8:
-                        _error_2 = _c.sent();
+                        return [2 /*return*/, axios.request(__assign({}, this.withCurrentAuth(originalConfig)))];
+                    case 9:
+                        _error_2 = _a.sent();
                         if (_error_2.response && _error_2.response.data) {
                             return [2 /*return*/, Promise.reject(_error_2.response.data)];
                         }
                         return [2 /*return*/, Promise.reject(_error_2)];
-                    case 9: return [2 /*return*/, Promise.reject(err)];
+                    case 10: return [2 /*return*/, Promise.reject(err)];
                 }
             });
         }); });

package/dist/common.d.ts

@@ -62,7 +62,7 @@ export declare const toPathString: (url: URL) => string;
  *
  * @export
  */
-export declare const createRequestFunction: (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) => <T = unknown, R = AxiosResponse<T, any, {}>>(axios?: AxiosInstance, basePath?: string) => Promise<R>;
+export declare const createRequestFunction: (axiosArgs: RequestArgs, globalAxios: AxiosInstance, BASE_PATH: string, configuration?: Configuration) => <T = unknown, R = AxiosResponse<T, any, {}, any>>(axios?: AxiosInstance, basePath?: string) => Promise<R>;
 /**
  * EMIL MigrationService
  * The EMIL MigrationService API description

package/dist/common.js

@@ -233,6 +233,7 @@ exports.toPathString = toPathString;
  * @export
  */
 var createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, configuration) {
+    // Typed by hand: since axios 1.20, request() returns an internal axios type that SDK declarations cannot name.
     return function (axios, basePath) {
         if (axios === void 0) { axios = globalAxios; }
         if (basePath === void 0) { basePath = BASE_PATH; }

package/dist/configuration.d.ts

@@ -18,6 +18,7 @@ export interface ConfigurationParameters {
     baseOptions?: any;
     formDataCtor?: new () => any;
     cookieAuth?: boolean;
+    account?: string;
 }
 export declare class Configuration {
     /**
@@ -70,13 +71,20 @@ export declare class Configuration {
      */
     formDataCtor?: new () => any;
     /**
-     * Authenticate with the HttpOnly access cookie instead of a stored token: every call sends credentials.
-     * The browser holds one cookie, so use it with one logged-in account; log out through the auth service.
+     * Use a server session when authservice makes one; otherwise the token, as without this option.
+     * Set `account` too, so each SDK object keeps its own account.
      *
      * @type {boolean}
      * @memberof Configuration
      */
     cookieAuth?: boolean;
+    /**
+     * The session account (Cognito sub) this app shows, so the SDK never takes another tab's account.
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    account?: string;
     constructor(param?: ConfigurationParameters);
     /**
      * Check if the given MIME is a JSON MIME.

package/dist/configuration.js

@@ -25,6 +25,7 @@ var Configuration = /** @class */ (function () {
         this.baseOptions = param.baseOptions;
         this.formDataCtor = param.formDataCtor;
         this.cookieAuth = param.cookieAuth;
+        this.account = param.account;
     }
     /**
      * Check if the given MIME is a JSON MIME.

package/dist/models/create-ingest-run-async-request-dto.d.ts

@@ -39,5 +39,6 @@ export declare const CreateIngestRunAsyncRequestDtoSourceEntityEnum: {
     readonly PartnerRelations: "partner_relations";
     readonly Policies: "policies";
     readonly Leads: "leads";
+    readonly Claims: "claims";
 };
 export type CreateIngestRunAsyncRequestDtoSourceEntityEnum = typeof CreateIngestRunAsyncRequestDtoSourceEntityEnum[keyof typeof CreateIngestRunAsyncRequestDtoSourceEntityEnum];

package/dist/models/create-ingest-run-async-request-dto.js

@@ -18,5 +18,6 @@ exports.CreateIngestRunAsyncRequestDtoSourceEntityEnum = {
     Partners: 'partners',
     PartnerRelations: 'partner_relations',
     Policies: 'policies',
-    Leads: 'leads'
+    Leads: 'leads',
+    Claims: 'claims'
 };

package/dist/models/create-ingest-run-sync-request-dto.d.ts

@@ -41,5 +41,6 @@ export declare const CreateIngestRunSyncRequestDtoSourceEntityEnum: {
     readonly PartnerRelations: "partner_relations";
     readonly Policies: "policies";
     readonly Leads: "leads";
+    readonly Claims: "claims";
 };
 export type CreateIngestRunSyncRequestDtoSourceEntityEnum = typeof CreateIngestRunSyncRequestDtoSourceEntityEnum[keyof typeof CreateIngestRunSyncRequestDtoSourceEntityEnum];

package/dist/models/create-ingest-run-sync-request-dto.js

@@ -18,5 +18,6 @@ exports.CreateIngestRunSyncRequestDtoSourceEntityEnum = {
     Partners: 'partners',
     PartnerRelations: 'partner_relations',
     Policies: 'policies',
-    Leads: 'leads'
+    Leads: 'leads',
+    Claims: 'claims'
 };

package/dist/models/flush-ingested-data-request-dto.d.ts

@@ -33,5 +33,6 @@ export declare const FlushIngestedDataRequestDtoDataTypeEnum: {
     readonly PartnerRelations: "partner_relations";
     readonly Policies: "policies";
     readonly Leads: "leads";
+    readonly Claims: "claims";
 };
 export type FlushIngestedDataRequestDtoDataTypeEnum = typeof FlushIngestedDataRequestDtoDataTypeEnum[keyof typeof FlushIngestedDataRequestDtoDataTypeEnum];

package/dist/models/flush-ingested-data-request-dto.js

@@ -18,5 +18,6 @@ exports.FlushIngestedDataRequestDtoDataTypeEnum = {
     Partners: 'partners',
     PartnerRelations: 'partner_relations',
     Policies: 'policies',
-    Leads: 'leads'
+    Leads: 'leads',
+    Claims: 'claims'
 };

package/models/create-ingest-run-async-request-dto.ts

@@ -44,7 +44,8 @@ export const CreateIngestRunAsyncRequestDtoSourceEntityEnum = {
     Partners: 'partners',
     PartnerRelations: 'partner_relations',
     Policies: 'policies',
-    Leads: 'leads'
+    Leads: 'leads',
+    Claims: 'claims'
 } as const;
 
 export type CreateIngestRunAsyncRequestDtoSourceEntityEnum = typeof CreateIngestRunAsyncRequestDtoSourceEntityEnum[keyof typeof CreateIngestRunAsyncRequestDtoSourceEntityEnum];

package/models/create-ingest-run-sync-request-dto.ts

@@ -44,7 +44,8 @@ export const CreateIngestRunSyncRequestDtoSourceEntityEnum = {
     Partners: 'partners',
     PartnerRelations: 'partner_relations',
     Policies: 'policies',
-    Leads: 'leads'
+    Leads: 'leads',
+    Claims: 'claims'
 } as const;
 
 export type CreateIngestRunSyncRequestDtoSourceEntityEnum = typeof CreateIngestRunSyncRequestDtoSourceEntityEnum[keyof typeof CreateIngestRunSyncRequestDtoSourceEntityEnum];

package/models/flush-ingested-data-request-dto.ts

@@ -38,7 +38,8 @@ export const FlushIngestedDataRequestDtoDataTypeEnum = {
     Partners: 'partners',
     PartnerRelations: 'partner_relations',
     Policies: 'policies',
-    Leads: 'leads'
+    Leads: 'leads',
+    Claims: 'claims'
 } as const;
 
 export type FlushIngestedDataRequestDtoDataTypeEnum = typeof FlushIngestedDataRequestDtoDataTypeEnum[keyof typeof FlushIngestedDataRequestDtoDataTypeEnum];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emilgroup/migration-sdk",
-  "version": "0.10.1-beta.13",
+  "version": "0.10.1-beta.17",
   "description": "OpenAPI client for @emilgroup/migration-sdk",
   "author": "OpenAPI-Generator Contributors",
   "keywords": [
@@ -18,7 +18,7 @@
     "prepare": "npm run build"
   },
   "dependencies": {
-    "axios": "1.18.0"
+    "axios": "1.20.0"
   },
   "devDependencies": {