@cognigy/rest-api-client 0.20.0 → 4.94.0

package/dist/esm/apigroups/SessionsAPIGroup_2_0.js

@@ -0,0 +1,26 @@
+import { __rest } from "tslib";
+import { GenericAPIFn } from "../GenericAPIFn";
+export function SessionsAPIGroup_2_0(instance) {
+    const self = instance;
+    return {
+        inject: (args, options) => GenericAPIFn("/new/v2.0/endpoint/inject", "POST", self)(args, options),
+        notify: (args, options) => GenericAPIFn("/new/v2.0/endpoint/notify", "POST", self)(args, options),
+        injectContext: (_a, options) => {
+            var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
+            return GenericAPIFn(`/new/v2.0/sessions/${sessionId}/context/inject`, "POST", self)(args, options);
+        },
+        resetContext: (_a, options) => {
+            var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
+            return GenericAPIFn(`/new/v2.0/sessions/${sessionId}/context/reset`, "POST", self)(args, options);
+        },
+        injectState: (_a, options) => {
+            var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
+            return GenericAPIFn(`/new/v2.0/sessions/${sessionId}/state/inject`, "POST", self)(args, options);
+        },
+        resetState: (_a, options) => {
+            var { sessionId } = _a, args = __rest(_a, ["sessionId"]);
+            return GenericAPIFn(`/new/v2.0/sessions/${sessionId}/state/reset`, "POST", self)(args, options);
+        }
+    };
+}
+//# sourceMappingURL=SessionsAPIGroup_2_0.js.map

package/dist/esm/apigroups/TRestAPIGroupsTypeByConfiguration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TRestAPIGroupsTypeByConfiguration.js.map

package/dist/esm/apigroups/TRestAPIOperation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TRestAPIOperation.js.map

package/dist/esm/apigroups/TTusAPIOperation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TTusAPIOperation.js.map

package/dist/esm/apigroups/index.js

@@ -0,0 +1,13 @@
+// AdministrationAPIGroup;
+export { AdministrationAPIGroup_2_0 } from "./AdministrationAPIGroup_2_0";
+export { AdministrationAPIGroup_2_1 } from "./AdministrationAPIGroup_2_1";
+export { ExternalAPIGroup_2_0 } from "./ExternalAPIGroup_2_0";
+export { InsightsAPIGroup_2_0 } from "./InsightsAPIGroup_2_0";
+export { JWTAuthAPIGroup_2_0 } from "./JWTAuthAPIGroup_2_0";
+export { MetricsAPIGroup_2_0 } from "./MetricsAPIGroup_2_0";
+export { ManagementAPIGroup_2_0 } from "./ManagementAPIGroup_2_0";
+// ResourcesAPIGroup
+export { ResourcesAPIGroup_2_0 } from "./ResourcesAPIGroup_2_0";
+export { SessionsAPIGroup_2_0 } from "./SessionsAPIGroup_2_0";
+export { AnalyticsAPIGroup_2_0 } from "./AnalyticsAPIGroup_2_0";
+//# sourceMappingURL=index.js.map

package/dist/esm/authentication/ApiKey/ApiKeyAuthentication.js

@@ -0,0 +1,21 @@
+import { __awaiter } from "tslib";
+export const ApiKeyAuthentication = function (credentials, self) {
+    if (!(this instanceof ApiKeyAuthentication)) {
+        return new ApiKeyAuthentication(credentials, self);
+    }
+    else {
+        self.credentials = {
+            apiKey: credentials.apiKey,
+            type: credentials.type
+        };
+        const ApiKeyAuthentication = function () { };
+        ApiKeyAuthentication.prototype.getAuthenticationHeaders = () => __awaiter(this, void 0, void 0, function* () {
+            const headers = {};
+            headers["x-api-key"] = credentials.apiKey || "";
+            return headers;
+        });
+        return new ApiKeyAuthentication(credentials, self);
+    }
+};
+export default ApiKeyAuthentication;
+//# sourceMappingURL=ApiKeyAuthentication.js.map

package/dist/esm/authentication/ApiKey/IApiKeyAuthentication.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IApiKeyAuthentication.js.map

package/dist/esm/authentication/AuthenticationAPI.js

@@ -0,0 +1,56 @@
+import { __awaiter, __rest } from "tslib";
+import { GenericAPIFn } from "../GenericAPIFn";
+/* Authentication Methods */
+import { ApiKeyAuthentication } from "./ApiKey/ApiKeyAuthentication";
+import { BasicAuthentication } from "./BasicAuthentication/BasicAuthentication";
+import { OAuth2Authentication } from "./OAuth2/OAuth2Authentication";
+import { stringifyQuery } from "../shared/helper/rest";
+export function AuthenticationAPI(instance) {
+    const self = instance;
+    return {
+        setCredentials: (credentials) => {
+            switch (credentials.type) {
+                case "ApiKey":
+                    self.authenticationHandler = new ApiKeyAuthentication(credentials, self);
+                    break;
+                case "Basic":
+                    self.authenticationHandler = new BasicAuthentication(credentials, self);
+                    break;
+                case "OAuth2":
+                    self.authenticationHandler = new OAuth2Authentication(credentials, self);
+                    break;
+            }
+        },
+        login: (data) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.login(data);
+        }),
+        logout: () => __awaiter(this, void 0, void 0, function* () {
+            var _b;
+            return (_b = self.authenticationHandler) === null || _b === void 0 ? void 0 : _b.logout();
+        }),
+        getAccessToken: () => __awaiter(this, void 0, void 0, function* () {
+            var _c;
+            return (_c = self.authenticationHandler) === null || _c === void 0 ? void 0 : _c.getAccessToken();
+        }),
+        getRefreshToken: () => {
+            var _a;
+            return (_a = self.authenticationHandler) === null || _a === void 0 ? void 0 : _a.getRefreshToken();
+        },
+        isLoggedIn: () => __awaiter(this, void 0, void 0, function* () {
+            var _d;
+            return (_d = self.authenticationHandler) === null || _d === void 0 ? void 0 : _d.isLoggedIn();
+        }),
+        getRealtimeToken: (options) => GenericAPIFn("/auth/realtimetoken", "POST", self)(undefined, options),
+        webfinger: (args, options) => GenericAPIFn(`/.well-known/webfinger?${stringifyQuery(args)}`, "GET", self)(undefined, Object.assign({ withAuthentication: false }, options)),
+        getAuthorizationCode: (data) => __awaiter(this, void 0, void 0, function* () {
+            var _e;
+            return (_e = self.authenticationHandler) === null || _e === void 0 ? void 0 : _e.getAuthorizationCode(data);
+        }),
+        exchangeOneTimeTokenForRefreshToken: (_a, options) => {
+            var { loginToken } = _a, args = __rest(_a, ["loginToken"]);
+            return GenericAPIFn(`/auth/exchangetoken?${stringifyQuery({ loginToken })}`, "GET", self)(args, Object.assign({ withAuthentication: false }, options));
+        }
+    };
+}
+//# sourceMappingURL=AuthenticationAPI.js.map

package/dist/esm/authentication/BasicAuthentication/BasicAuthentication.js

@@ -0,0 +1,30 @@
+import { __awaiter } from "tslib";
+export const BasicAuthentication = function (credentials, self) {
+    if (!(this instanceof BasicAuthentication)) {
+        return new BasicAuthentication(credentials, self);
+    }
+    else {
+        self.credentials = {
+            username: credentials.username,
+            password: credentials.password,
+            type: credentials.type
+        };
+        const BasicAuthentication = function () { };
+        BasicAuthentication.prototype.getAuthenticationHeaders = () => __awaiter(this, void 0, void 0, function* () {
+            const headers = {};
+            let credential = `${credentials.username}:${credentials.password}`;
+            // accessing an undefined variable Buffer in the browser throws a reference error
+            if (typeof Buffer !== "undefined") {
+                credential = Buffer.from(credential, "binary").toString("base64");
+            }
+            else {
+                credential = btoa(credential);
+            }
+            headers["Authorization"] = `Basic ${credential}`;
+            return headers;
+        });
+        return new BasicAuthentication(credentials, self);
+    }
+};
+export default BasicAuthentication;
+//# sourceMappingURL=BasicAuthentication.js.map

package/dist/esm/authentication/BasicAuthentication/IBasicAuthentication.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IBasicAuthentication.js.map

package/dist/esm/authentication/OAuth2/IGetAuthorizationCodeParameters.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IGetAuthorizationCodeParameters.js.map

package/dist/esm/authentication/OAuth2/ILoginByAuthorizationCodeParameters.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ILoginByAuthorizationCodeParameters.js.map

package/dist/esm/authentication/OAuth2/ILoginByClientCredentialsParameters.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ILoginByClientCredentialsParameters.js.map

package/dist/esm/authentication/OAuth2/ILoginByPasswordParameters.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ILoginByPasswordParameters.js.map

package/dist/esm/authentication/OAuth2/ILoginByRefreshTokenParameters.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ILoginByRefreshTokenParameters.js.map

package/dist/esm/authentication/OAuth2/IOAuth2Authentication.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IOAuth2Authentication.js.map

package/dist/esm/authentication/OAuth2/IOAuth2AuthorizationCodeGrantRequest.js

@@ -0,0 +1,10 @@
+/**
+ * The client makes a request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+export {};
+//# sourceMappingURL=IOAuth2AuthorizationCodeGrantRequest.js.map

package/dist/esm/authentication/OAuth2/IOAuth2ClientCredentialsGrantAccessTokenRequest.js

@@ -0,0 +1,10 @@
+/**
+ * The client makes a request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.3.2
+ */
+export {};
+//# sourceMappingURL=IOAuth2ClientCredentialsGrantAccessTokenRequest.js.map

package/dist/esm/authentication/OAuth2/IOAuth2ClientPassword.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IOAuth2ClientPassword.js.map

package/dist/esm/authentication/OAuth2/IOAuth2ErrorResponse.js

@@ -0,0 +1,38 @@
+export const OAuth2Errors = [
+    /**
+     * The request is missing a required parameter, includes an unsupported parameter
+     * value, or is otherwise malformed.
+     */
+    "invalid_request",
+    /**
+     * The client is not authorized to request an authorization code using this method.
+     */
+    "unauthorized_client",
+    /**
+     * The resource owner or authorization server denied the request.
+     */
+    "access_denied",
+    /**
+     * The authorization server does not support obtaining an authorization code using
+     * this method.
+     */
+    "unsupported_response_type",
+    /**
+     * The requested scope is invalid, unknown, or malformed.
+     */
+    "invalid_scope",
+    /**
+     * The authorization server encountered an unexpected
+     * condition that prevented it from fulfilling the request.
+     * (This error code is needed because a 500 Internal Server
+     * Error HTTP status code cannot be returned to the client
+     * via an HTTP redirect.)
+     */
+    "server_error",
+    /**
+     * The authorization server is currently unable to handle the request because of a
+     * temporary overloading or maintenance of the server.
+     */
+    "temporarily_unavailable"
+];
+//# sourceMappingURL=IOAuth2ErrorResponse.js.map

package/dist/esm/authentication/OAuth2/IOAuth2GetAuthorizationCodeRequest.js

@@ -0,0 +1,10 @@
+/**
+ * The client makes a request to the authorize endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+ */
+export {};
+//# sourceMappingURL=IOAuth2GetAuthorizationCodeRequest.js.map

package/dist/esm/authentication/OAuth2/IOAuth2PasswordGrantAccessTokenRequest.js

@@ -0,0 +1,10 @@
+/**
+ * The client makes a request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-4.3.2
+ */
+export {};
+//# sourceMappingURL=IOAuth2PasswordGrantAccessTokenRequest.js.map

package/dist/esm/authentication/OAuth2/IOAuth2RefreshAccessTokenRequest.js

@@ -0,0 +1,11 @@
+/**
+ * If the authorization server issued a refresh token to the client, the
+ * client makes a refresh request to the token endpoint by adding the
+ * following parameters using the "application/x-www-form-urlencoded"
+ * format per Appendix B with a character encoding of UTF-8 in the HTTP
+ * request entity-body:
+ *
+ * @see https://tools.ietf.org/html/rfc6749#section-6
+ */
+export {};
+//# sourceMappingURL=IOAuth2RefreshAccessTokenRequest.js.map

package/dist/esm/authentication/OAuth2/IOAuth2SuccessResponse.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IOAuth2SuccessResponse.js.map

package/dist/esm/authentication/OAuth2/OAuth2Authentication.js

@@ -0,0 +1,241 @@
+import { __awaiter } from "tslib";
+/* Custom Modules */
+import { OAuth2Error } from "./OAuth2Error";
+import { HttpStatusCode } from "../../shared/helper/HttpStatusCode";
+import { UnauthorizedError } from "../../shared/errors";
+import { OAuth2Errors } from "./IOAuth2ErrorResponse";
+const expiryBuffer = 8;
+export const OAuth2Authentication = function (credentials, self) {
+    if (!(this instanceof OAuth2Authentication)) {
+        return new OAuth2Authentication(credentials, self);
+    }
+    else {
+        self.refreshTokenSingleton = null;
+        self.credentials = {
+            type: credentials.type,
+            clientId: credentials.clientId,
+            clientSecret: credentials.clientSecret
+        };
+        self.tokenData = {};
+        const refreshTokenGrant = (data) => __awaiter(this, void 0, void 0, function* () {
+            const { clientId, clientSecret, refreshToken } = data;
+            const formFields = {
+                grant_type: "refresh_token",
+                refresh_token: refreshToken,
+                client_id: clientId,
+                client_secret: clientSecret
+            };
+            return yield request(formFields, {
+                maxRetries: Infinity,
+                retryDelay: () => 3000
+            });
+        });
+        const request = (formFields, options) => __awaiter(this, void 0, void 0, function* () {
+            const payload = new URLSearchParams(formFields).toString();
+            const httpAdapter = self.getHttpAdapter();
+            let url;
+            if (isAuthorizationRequest(formFields)) {
+                url = "/auth/oauth2/authorize";
+            }
+            else {
+                url = "/auth/oauth2/token";
+            }
+            const requestData = Object.assign({ headers: {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                }, method: "POST", url, data: payload }, options);
+            //@ts-ignore - organisationId
+            if (formFields.organisationId) {
+                //@ts-ignore - organisationId
+                requestData.headers["organisation-id"] = formFields.organisationId;
+                //@ts-ignore - organisationId
+                delete formFields.organisationId;
+                requestData.data = new URLSearchParams(formFields).toString();
+            }
+            const response = yield httpAdapter.request(requestData, self);
+            if (response.status === HttpStatusCode.OK) {
+                const result = response.data;
+                result.expires_at =
+                    Date.now() + (result.expires_in - expiryBuffer) * 1000;
+                return result;
+            }
+            if (typeof response.data.error === "string") {
+                const error = response.data.error;
+                if (OAuth2Errors.includes(error.error)) {
+                    throw new OAuth2Error();
+                }
+            }
+        });
+        const isAccessTokenExpired = (tokenData) => {
+            var _a;
+            return Date.now() > ((_a = tokenData.expires_at) !== null && _a !== void 0 ? _a : 0);
+        };
+        const OAuth2Authentication = function () { };
+        OAuth2Authentication.prototype.getAuthenticationHeaders = () => __awaiter(this, void 0, void 0, function* () {
+            const headers = {};
+            if ((self === null || self === void 0 ? void 0 : self.credentials.type) ===
+                "OAuth2") {
+                yield getToken();
+                headers["Authorization"] = `${self.tokenData.token_type} ${self.tokenData.access_token}`;
+            }
+            return headers;
+        });
+        OAuth2Authentication.prototype.login = (parameters) => __awaiter(this, void 0, void 0, function* () {
+            const { clientId, clientSecret } = self.credentials;
+            switch (parameters.type) {
+                case "password":
+                    {
+                        const { username, password, rememberMe, organisationId } = parameters;
+                        const formFields = {
+                            grant_type: "password",
+                            username: username,
+                            password: password,
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                            rememberMe,
+                            organisationId
+                        };
+                        self.tokenData = yield request(formFields, {
+                            maxRetries: 0
+                        });
+                    }
+                    break;
+                case "refreshToken":
+                    {
+                        const { refreshToken } = parameters;
+                        const credentials = self.credentials;
+                        const result = yield refreshTokenGrant({
+                            clientId: credentials.clientId,
+                            clientSecret: credentials.clientSecret,
+                            refreshToken
+                        });
+                        self.tokenData = Object.assign(Object.assign(Object.assign({}, self.tokenData), { refresh_token: refreshToken }), result);
+                    }
+                    break;
+                case "authorizationCode":
+                    {
+                        const { code, redirectUri, codeVerifier } = parameters;
+                        const formFields = {
+                            grant_type: "authorization_code",
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                            code,
+                            redirect_uri: redirectUri,
+                            code_verifier: codeVerifier
+                        };
+                        self.tokenData = yield request(formFields, {
+                            maxRetries: 0
+                        });
+                    }
+                    break;
+                case "clientCredentials":
+                    {
+                        const { scope } = parameters;
+                        const formFields = {
+                            grant_type: "client_credentials",
+                            scope: scope,
+                            client_id: clientId,
+                            client_secret: clientSecret
+                        };
+                        self.tokenData = yield request(formFields, {
+                            maxRetries: 0
+                        });
+                    }
+                    break;
+            }
+        });
+        OAuth2Authentication.prototype.getAuthorizationCode = (parameters) => __awaiter(this, void 0, void 0, function* () {
+            const { username, password, redirectUri, state, organisationId, codeChallenge, codeChallengeMethod } = parameters;
+            const { clientId } = self.credentials;
+            const formFields = {
+                response_type: "code",
+                username: username,
+                password: password,
+                client_id: clientId,
+                state,
+                organisationId,
+                code_challenge: codeChallenge,
+                code_challenge_method: codeChallengeMethod
+            };
+            if (redirectUri) {
+                formFields.redirect_uri = redirectUri;
+            }
+            const code = yield request(formFields, {
+                maxRetries: 0
+            });
+            return code;
+        });
+        const getToken = () => __awaiter(this, void 0, void 0, function* () {
+            if ((self === null || self === void 0 ? void 0 : self.credentials.type) ===
+                "OAuth2") {
+                if (self.refreshTokenSingleton !== null) {
+                    yield self.refreshTokenSingleton;
+                }
+                /*
+                 * Check if AccessToken is still valid and if not trigger an refresh token grant flow
+                 */
+                if (isAccessTokenExpired(self.tokenData)) {
+                    const credentials = self.credentials;
+                    if (!self.tokenData.refresh_token) {
+                        throw new UnauthorizedError("No RefreshToken provided.");
+                    }
+                    if (self.refreshTokenSingleton === null) {
+                        self.refreshTokenSingleton = new Promise((resolve, reject) => {
+                            refreshTokenGrant({
+                                clientId: credentials.clientId,
+                                clientSecret: credentials.clientSecret,
+                                refreshToken: self.tokenData.refresh_token
+                            })
+                                .then((result) => {
+                                self.tokenData = Object.assign(Object.assign({}, self.tokenData), result);
+                                self.refreshTokenSingleton = null;
+                                resolve();
+                            })
+                                .catch((reason) => {
+                                self.refreshTokenSingleton = null;
+                                self.tokenData = {};
+                                reject(reason);
+                            });
+                        });
+                        yield self.refreshTokenSingleton;
+                    }
+                }
+            }
+            return self.tokenData;
+        });
+        const isAuthorizationRequest = (value) => (value === null || value === void 0 ? void 0 : value.response_type) === "code";
+        OAuth2Authentication.prototype.getAccessToken = () => __awaiter(this, void 0, void 0, function* () {
+            const token = yield getToken();
+            return token.access_token;
+        });
+        OAuth2Authentication.prototype.getRefreshToken = () => {
+            var _a;
+            return (_a = self.tokenData) === null || _a === void 0 ? void 0 : _a.refresh_token;
+        };
+        OAuth2Authentication.prototype.isLoggedIn = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return !!((_a = self.tokenData) === null || _a === void 0 ? void 0 : _a.refresh_token);
+        });
+        OAuth2Authentication.prototype.logout = () => __awaiter(this, void 0, void 0, function* () {
+            if ((self === null || self === void 0 ? void 0 : self.credentials.type) ===
+                "OAuth2" &&
+                self.tokenData.refresh_token) {
+                const httpAdapter = self.getHttpAdapter();
+                const requestData = {
+                    method: "POST",
+                    url: "/auth/oauth2/revoke",
+                    data: {
+                        token: self.tokenData.refresh_token
+                    },
+                    maxRetries: 3,
+                    retryDelay: () => 0
+                };
+                // reset tokenData to avoid multiple revoke calls
+                self.tokenData = {};
+                yield httpAdapter.request(requestData, self);
+            }
+        });
+        return new OAuth2Authentication(credentials, self);
+    }
+};
+export default OAuth2Authentication;
+//# sourceMappingURL=OAuth2Authentication.js.map

package/dist/esm/authentication/OAuth2/OAuth2Error.js

@@ -0,0 +1,6 @@
+export class OAuth2Error extends Error {
+    constructor() {
+        super();
+    }
+}
+//# sourceMappingURL=OAuth2Error.js.map

package/dist/esm/authentication/OAuth2/TOAuth2AccessTokenType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TOAuth2AccessTokenType.js.map

package/dist/esm/authentication/interfaces/IAuthenticationAdapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAuthenticationAdapter.js.map

package/dist/esm/authentication/interfaces/IAuthenticationConstructor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IAuthenticationConstructor.js.map

package/dist/esm/authentication/interfaces/TAuthenticationParameter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TAuthenticationParameter.js.map