@singularsystems/neo-core 1.0.0-alpha.3 → 1.0.0-beta.0

package/dist/Security/Oidc/OidcAuthService.js

@@ -1,189 +1,216 @@
-import { __awaiter, __decorate, __generator, __metadata } from "tslib";
-import { Observable } from '../../Model/Decorators';
-import OidcUser from './OidcUser';
-import { SignInResult } from '../SignInResult';
-import { Misc } from '../../';
-import { NeoTypes } from '../../AppServices';
-/**
- * Oidc authentication service base class.
- * You must override this class and provide the user manager implementation from the oidc library.
- */
-var OidcAuthService = /** @class */ (function () {
-    /**
-     * Creates an Oidc auth service
-     * @param userManager Oidc-client user manager instance
-     * @param user User which existed in storage at startup
-     */
-    function OidcAuthService(userManager, axios) {
-        this.userManager = userManager;
-        this.axios = axios;
-        this._user = null;
-        this.userManager = userManager;
-        this.userManager.events.addUserLoaded(this.onUserLoaded.bind(this));
-        this.userManager.events.addUserUnloaded(this.onUserUnloaded.bind(this));
-        this.userManager.events.addAccessTokenExpiring(this.signinSilent.bind(this));
-    }
-    OidcAuthService.prototype.loadUserFromToken = function () {
-        return this.loadUserFromSession();
-    };
-    OidcAuthService.prototype.loadUserFromSession = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var user;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.userManager.getUser()];
-                    case 1:
-                        user = _a.sent();
-                        if (user) {
-                            // Get user does not raise the onUserLoaded event, so we call it manually.
-                            this.onUserLoaded(user);
-                        }
-                        return [2 /*return*/, this.user];
-                }
-            });
-        });
-    };
-    /**
-     * Redirect to identity server to get the auth token.
-     * @param redirectPath Local path to redirect to once login is complete.
-     */
-    OidcAuthService.prototype.beginSignIn = function (redirectPath) {
-        return this.userManager.signinRedirect({ state: redirectPath });
-    };
-    ;
-    /**
-     * Reads the access token from the query string and returns the redirect path.
-     */
-    OidcAuthService.prototype.endSignIn = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var user, e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.userManager.signinRedirectCallback()];
-                    case 1:
-                        user = _a.sent();
-                        return [2 /*return*/, Promise.resolve(user.state || "")];
-                    case 2:
-                        e_1 = _a.sent();
-                        console.error(e_1);
-                        return [2 /*return*/, Promise.reject(e_1)];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Checks if the login state exists, and logs in the user.
-     * Result.success will be false if an error occurs. Errors will be handled by the service bound to NeoTypes.Security.LoginErrorHandler.
-     */
-    OidcAuthService.prototype.tryCompleteSignIn = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var queryParams, stateKey, loginErrorHandler, redirectPath, e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        queryParams = new URLSearchParams(window.location.search);
-                        stateKey = queryParams.get("state");
-                        loginErrorHandler = Misc.Globals.appService.get(NeoTypes.Security.LoginErrorHandler);
-                        if (!(!stateKey || window.localStorage.getItem("oidc." + stateKey) === null)) return [3 /*break*/, 1];
-                        loginErrorHandler.onMissingLoginState();
-                        return [3 /*break*/, 6];
-                    case 1:
-                        _a.trys.push([1, 5, , 6]);
-                        return [4 /*yield*/, this.endSignIn()];
-                    case 2:
-                        redirectPath = _a.sent();
-                        if (!this.afterUserLoadedPromise) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.afterUserLoadedPromise];
-                    case 3:
-                        _a.sent();
-                        this.afterUserLoadedPromise = undefined;
-                        _a.label = 4;
-                    case 4: return [2 /*return*/, new SignInResult(true, redirectPath)];
-                    case 5:
-                        e_2 = _a.sent();
-                        loginErrorHandler.onException(e_2);
-                        return [3 /*break*/, 6];
-                    case 6: return [2 /*return*/, new SignInResult(false, "")];
-                }
-            });
-        });
-    };
-    OidcAuthService.prototype.endSignInSilent = function () {
-        return this.userManager.signinSilentCallback();
-    };
-    OidcAuthService.prototype.onUserLoaded = function (user) {
-        this.setUser(this.createUser(user));
-        this.afterUserLoadedPromise = this.afterUserLoaded();
-    };
-    OidcAuthService.prototype.afterUserLoaded = function () {
-    };
-    OidcAuthService.prototype.createUser = function (user) {
-        return new OidcUser(user);
-    };
-    OidcAuthService.prototype.onUserUnloaded = function () {
-        this.setUser(null);
-    };
-    OidcAuthService.prototype.setUser = function (user) {
-        if (user) {
-            this.axios.defaults.headers.common['Authorization'] = user.authKey;
-        }
-        else {
-            delete this.axios.defaults.headers.common['Authorization'];
-        }
-        this._user = user;
-    };
-    OidcAuthService.prototype.signinSilent = function () {
-        return this.userManager.signinSilent();
-    };
-    OidcAuthService.prototype.beginSignOut = function () {
-        if (this._user) {
-            this.userManager.signoutRedirect({ id_token_hint: this._user.userData.id_token });
-            this.signOutLocal();
-        }
-        this.userManager.clearStaleState();
-    };
-    ;
-    OidcAuthService.prototype.endSignOut = function () {
-        return this.userManager.signoutRedirectCallback();
-    };
-    ;
-    OidcAuthService.prototype.signOutLocal = function () {
-        this.setUser(null);
-    };
-    Object.defineProperty(OidcAuthService.prototype, "user", {
-        get: function () {
-            return this._user;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(OidcAuthService.prototype, "isAuthenticated", {
-        get: function () {
-            return this.user !== null && !this.user.hasExpired;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    OidcAuthService.createIdentityServerMetadata = function (identityServerUrl) {
-        return {
-            issuer: identityServerUrl,
-            jwks_uri: identityServerUrl + "/.well-known/openid-configuration/jwks",
-            authorization_endpoint: identityServerUrl + "/connect/authorize",
-            token_endpoint: identityServerUrl + "/connect/token",
-            userinfo_endpoint: identityServerUrl + "/connect/userinfo",
-            end_session_endpoint: identityServerUrl + "/connect/endsession",
-            check_session_iframe: identityServerUrl + "/connect/checksession",
-            revocation_endpoint: identityServerUrl + "/connect/revocation",
-            introspection_endpoint: identityServerUrl + "/connect/introspect"
-        };
-    };
-    __decorate([
-        Observable(),
-        __metadata("design:type", Object)
-    ], OidcAuthService.prototype, "_user", void 0);
-    return OidcAuthService;
-}());
-export default OidcAuthService;
+import { __awaiter, __decorate, __generator, __metadata } from "tslib";
+import { Observable } from '../../Model/Decorators';
+import OidcUser from './OidcUser';
+import { SignInResult } from '../SignInResult';
+import { Misc } from '../../';
+import { NeoTypes } from '../../AppServices';
+/**
+ * Oidc authentication service base class.
+ * You must override this class and provide the user manager implementation from the oidc library.
+ */
+var OidcAuthService = /** @class */ (function () {
+    /**
+     * Creates an Oidc auth service
+     * @param userManager Oidc-client user manager instance
+     * @param user User which existed in storage at startup
+     */
+    function OidcAuthService(userManager, axios) {
+        this.userManager = userManager;
+        this.axios = axios;
+        this._user = null;
+        this.userManager = userManager;
+        this.userManager.events.addUserLoaded(this.onUserLoaded.bind(this));
+        this.userManager.events.addUserUnloaded(this.onUserUnloaded.bind(this));
+        if (!this.userManager.settings.automaticSilentRenew) {
+            // If automaticSilentRenew is set to true, then the user manager will handle automatic renewal.
+            this.userManager.events.addAccessTokenExpiring(this.signinSilent.bind(this));
+        }
+    }
+    OidcAuthService.prototype.loadUserFromToken = function () {
+        return this.loadUserFromSession();
+    };
+    OidcAuthService.prototype.loadUserFromSession = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.userManager.getUser()];
+                    case 1:
+                        user = _a.sent();
+                        if (user) {
+                            // Get user does not raise the onUserLoaded event, so we call it manually.
+                            this.onUserLoaded(user);
+                        }
+                        return [2 /*return*/, this.user];
+                }
+            });
+        });
+    };
+    OidcAuthService.prototype.ensureSignedIn = function (redirectLocal) {
+        var settings = this.userManager.settings;
+        if (!this.isAuthenticated &&
+            (!settings.redirect_uri || !window.location.href.startsWith(settings.redirect_uri)) &&
+            (!settings.silent_redirect_uri || !window.location.href.startsWith(settings.silent_redirect_uri))) {
+            this.beginSignIn(redirectLocal);
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Redirect to identity server to get the auth token.
+     * @param redirectPath Local path to redirect to once login is complete.
+     */
+    OidcAuthService.prototype.beginSignIn = function (redirectPath) {
+        return this.userManager.signinRedirect({ state: redirectPath });
+    };
+    ;
+    /**
+     * Reads the access token from the query string and returns the redirect path.
+     */
+    OidcAuthService.prototype.endSignIn = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var user, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.userManager.signinRedirectCallback()];
+                    case 1:
+                        user = _a.sent();
+                        return [2 /*return*/, Promise.resolve(user.state || "")];
+                    case 2:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        return [2 /*return*/, Promise.reject(e_1)];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Checks if the login state exists, and logs in the user.
+     * Result.success will be false if an error occurs. Errors will be handled by the service bound to NeoTypes.Security.LoginErrorHandler.
+     */
+    OidcAuthService.prototype.tryCompleteSignIn = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParams, stateKey, loginErrorHandler, redirectPath, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParams = new URLSearchParams(window.location.search);
+                        stateKey = queryParams.get("state");
+                        loginErrorHandler = Misc.Globals.appService.get(NeoTypes.Security.LoginErrorHandler);
+                        if (!(!stateKey || window.localStorage.getItem("oidc." + stateKey) === null)) return [3 /*break*/, 1];
+                        loginErrorHandler.onMissingLoginState();
+                        return [3 /*break*/, 6];
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        return [4 /*yield*/, this.endSignIn()];
+                    case 2:
+                        redirectPath = _a.sent();
+                        if (!this.afterUserLoadedPromise) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.afterUserLoadedPromise];
+                    case 3:
+                        _a.sent();
+                        this.afterUserLoadedPromise = undefined;
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, new SignInResult(true, redirectPath)];
+                    case 5:
+                        e_2 = _a.sent();
+                        loginErrorHandler.onException(e_2);
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/, new SignInResult(false, "")];
+                }
+            });
+        });
+    };
+    OidcAuthService.prototype.endSignInSilent = function () {
+        return this.userManager.signinSilentCallback();
+    };
+    OidcAuthService.prototype.onUserLoaded = function (user) {
+        this.setUser(this.createUser(user));
+        this.afterUserLoadedPromise = this.afterUserLoaded();
+    };
+    OidcAuthService.prototype.afterUserLoaded = function () {
+    };
+    OidcAuthService.prototype.createUser = function (user) {
+        return new OidcUser(user);
+    };
+    OidcAuthService.prototype.onUserUnloaded = function () {
+        this.setUser(null);
+    };
+    OidcAuthService.prototype.setUser = function (user) {
+        if (user) {
+            this.axios.defaults.headers.common['Authorization'] = user.authKey;
+        }
+        else {
+            delete this.axios.defaults.headers.common['Authorization'];
+        }
+        this._user = user;
+    };
+    OidcAuthService.prototype.signinSilent = function () {
+        return this.userManager.signinSilent();
+    };
+    OidcAuthService.prototype.beginSignOut = function () {
+        if (this._user) {
+            this.userManager.signoutRedirect({ id_token_hint: this._user.userData.id_token });
+            this.signOutLocal();
+        }
+        this.userManager.clearStaleState();
+    };
+    ;
+    OidcAuthService.prototype.endSignOut = function () {
+        return this.userManager.signoutRedirectCallback();
+    };
+    ;
+    OidcAuthService.prototype.signOutLocal = function () {
+        this.setUser(null);
+    };
+    Object.defineProperty(OidcAuthService.prototype, "user", {
+        get: function () {
+            return this._user;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OidcAuthService.prototype, "isAuthenticated", {
+        get: function () {
+            return this.user !== null && !this.user.hasExpired;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OidcAuthService.createIdentityServerMetadata = function (identityServerUrl) {
+        return {
+            issuer: identityServerUrl,
+            jwks_uri: identityServerUrl + "/.well-known/openid-configuration/jwks",
+            authorization_endpoint: identityServerUrl + "/connect/authorize",
+            token_endpoint: identityServerUrl + "/connect/token",
+            userinfo_endpoint: identityServerUrl + "/connect/userinfo",
+            end_session_endpoint: identityServerUrl + "/connect/endsession",
+            check_session_iframe: identityServerUrl + "/connect/checksession",
+            revocation_endpoint: identityServerUrl + "/connect/revocation",
+            introspection_endpoint: identityServerUrl + "/connect/introspect"
+        };
+    };
+    /**
+     * If this is a silent sign in (based on the current uri), `endSignInSilent()` is called on the oidc client, and this method returns true.
+     * This should be called on startup of your app. If this returns true, don't continue with startup, since this iframe will be shortly disposed.
+     * @param silentRedirectRoute The app relative path used for silent sign in callbacks.
+     */
+    OidcAuthService.isSilentSignIn = function (silentRedirectRoute) {
+        var config = Misc.Globals.appService.get(NeoTypes.Config.ConfigModel);
+        var silentRedirectUri = "".concat(window.location.origin).concat(config.baseUrl).concat(silentRedirectRoute);
+        if (window.location.href.startsWith(silentRedirectUri)) {
+            Misc.Globals.appService.get(NeoTypes.Security.AuthenticationService).endSignInSilent();
+            return true;
+        }
+        return false;
+    };
+    __decorate([
+        Observable(),
+        __metadata("design:type", Object)
+    ], OidcAuthService.prototype, "_user", void 0);
+    return OidcAuthService;
+}());
+export default OidcAuthService;

package/dist/Security/Oidc/OidcTypes.d.ts

@@ -1,29 +1,46 @@
-export interface IOidcUser {
-    id_token: string;
-    token_type: string;
-    access_token: string;
-    profile: any;
-    expires_at: number;
-    /** State passed to IDS which is returned to us. */
-    state: any;
-    readonly expired: boolean | undefined;
-}
-export interface IUserManager {
-    events: IUserManagerEvents;
-    signinRedirect(args?: any): Promise<any>;
-    signinRedirectCallback(url?: string): Promise<IOidcUser>;
-    signoutRedirect(args?: any): Promise<any>;
-    signoutRedirectCallback(url?: string): Promise<any>;
-    signinSilent(args?: any): Promise<IOidcUser>;
-    signinSilentCallback(url?: string): Promise<any>;
-    clearStaleState(): Promise<void>;
-    getUser(): Promise<IOidcUser | null>;
-    createSigninRequest(args?: any): Promise<{
-        url: string;
-    }>;
-}
-export interface IUserManagerEvents {
-    addUserLoaded(callback: (...ev: any[]) => void): void;
-    addUserUnloaded(callback: (...ev: any[]) => void): void;
-    addAccessTokenExpiring(callback: (...ev: any[]) => void): void;
-}
+export interface IOidcUser {
+    /**
+     * A JSON Web Token (JWT). Only provided if `openid` scope was requested.
+     * The application can access the data decoded by using the `profile` property.
+     */
+    id_token?: string;
+    /** Typically "Bearer" */
+    token_type: string;
+    /**
+     * The requested access token returned from the OIDC provider. The application can use this token to
+     * authenticate itself to the secured resource.
+     */
+    access_token: string;
+    /** The scopes that the requested access token is valid for. */
+    scope?: string;
+    profile: any;
+    expires_at?: number;
+    /** State passed to IDS which is returned to us. */
+    state: any;
+    readonly expired: boolean | undefined;
+}
+export interface IUserManager {
+    events: IUserManagerEvents;
+    settings: IUserManagerSettings;
+    signinRedirect(args?: any): Promise<any>;
+    signinRedirectCallback(url?: string): Promise<IOidcUser>;
+    signoutRedirect(args?: any): Promise<any>;
+    signoutRedirectCallback(url?: string): Promise<any>;
+    signinSilent(args?: any): Promise<IOidcUser | null>;
+    signinSilentCallback(url?: string): Promise<any>;
+    clearStaleState(): Promise<void>;
+    getUser(): Promise<IOidcUser | null>;
+}
+export interface IUserManagerSettings {
+    /** The redirect URI of your client application to receive a response from the OIDC/OAuth2 provider */
+    redirect_uri?: string;
+    /** Flag to indicate if there should be an automatic attempt to renew the access token prior to its expiration */
+    automaticSilentRenew?: boolean;
+    /** The URL for the page containing the code handling the silent renew */
+    silent_redirect_uri?: string;
+}
+export interface IUserManagerEvents {
+    addUserLoaded(callback: (...ev: any[]) => void): void;
+    addUserUnloaded(callback: (...ev: any[]) => void): void;
+    addAccessTokenExpiring(callback: (...ev: any[]) => void): void;
+}

package/dist/Security/Oidc/OidcTypes.js

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

package/dist/Security/Oidc/OidcUser.d.ts

@@ -1,9 +1,9 @@
-import { User } from '../User';
-import { IOidcUser } from './OidcTypes';
-export default class OidcUser extends User {
-    userData: IOidcUser;
-    constructor(userData: IOidcUser);
-    get hasExpired(): boolean;
-    get authKey(): string;
-    get accessToken(): string;
-}
+import { User } from '../User';
+import { IOidcUser } from './OidcTypes';
+export default class OidcUser extends User {
+    userData: IOidcUser;
+    constructor(userData: IOidcUser);
+    get hasExpired(): boolean;
+    get authKey(): string;
+    get accessToken(): string;
+}

package/dist/Security/Oidc/OidcUser.js

@@ -1,33 +1,33 @@
-import { __extends } from "tslib";
-import { User } from '../User';
-var OidcUser = /** @class */ (function (_super) {
-    __extends(OidcUser, _super);
-    function OidcUser(userData) {
-        var _this = _super.call(this, userData.profile.name, userData.profile.preferred_username, userData.profile.given_name, userData.profile.family_name) || this;
-        _this.userData = userData;
-        return _this;
-    }
-    Object.defineProperty(OidcUser.prototype, "hasExpired", {
-        get: function () {
-            return this.userData.expired;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(OidcUser.prototype, "authKey", {
-        get: function () {
-            return this.userData.token_type + " " + this.userData.access_token;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(OidcUser.prototype, "accessToken", {
-        get: function () {
-            return this.userData.access_token;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return OidcUser;
-}(User));
-export default OidcUser;
+import { __extends } from "tslib";
+import { User } from '../User';
+var OidcUser = /** @class */ (function (_super) {
+    __extends(OidcUser, _super);
+    function OidcUser(userData) {
+        var _this = _super.call(this, userData.profile.name, userData.profile.preferred_username, userData.profile.given_name, userData.profile.family_name) || this;
+        _this.userData = userData;
+        return _this;
+    }
+    Object.defineProperty(OidcUser.prototype, "hasExpired", {
+        get: function () {
+            return this.userData.expired;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OidcUser.prototype, "authKey", {
+        get: function () {
+            return this.userData.token_type + " " + this.userData.access_token;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OidcUser.prototype, "accessToken", {
+        get: function () {
+            return this.userData.access_token;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OidcUser;
+}(User));
+export default OidcUser;

package/dist/Security/SecurityService.d.ts

@@ -1,12 +1,12 @@
-import IAuthenticationService from './IAuthenticationService';
-import IAuthorisationService from './IAuthorisationService';
-import ISecurityService from './ISecurityService';
-import { IUser } from './IUser';
-export declare class SecurityService implements ISecurityService {
-    authentication: IAuthenticationService;
-    authorisation: IAuthorisationService;
-    constructor(authentication: IAuthenticationService, authorisation: IAuthorisationService);
-    get isAuthenticated(): boolean;
-    get user(): IUser | null;
-    hasRole(roleName: string): boolean;
-}
+import IAuthenticationService from './IAuthenticationService';
+import IAuthorisationService from './IAuthorisationService';
+import ISecurityService from './ISecurityService';
+import { IUser } from './IUser';
+export declare class SecurityService implements ISecurityService {
+    authentication: IAuthenticationService;
+    authorisation: IAuthorisationService;
+    constructor(authentication: IAuthenticationService, authorisation: IAuthorisationService);
+    get isAuthenticated(): boolean;
+    get user(): IUser | null;
+    hasRole(roleName: string): boolean;
+}